开源白板工具(SaaS),一体化白板,包含思维导图、流程图、自由画等。All in one open-source whiteboard tool with mind, flowchart, freehand and etc.
feat(freehand): 基于 freehand-presets 的画笔更新 (#390)
Nightt61c8adc4c2a5
diff --git a/packages/drawnix/src/components/size-slider.scss b/packages/drawnix/src/components/size-slider.scssindex 1092b0e..5f51bc6 100644--- a/packages/drawnix/src/components/size-slider.scss+++ b/packages/drawnix/src/components/size-slider.scss@@ -1,38 +1,85 @@@import "open-color/open-color.scss";.slider-container {- padding: 10px 0px;- &.disabled {- opacity: 50%;- cursor: not-allowed;-- .slider-track,.slider-thumb {- cursor: not-allowed;- }+ padding: 10px 0;++ &.disabled {+ opacity: 50%;+ cursor: not-allowed;++ .slider-track,+ .slider-thumb {+ cursor: not-allowed;}+ }++ &.slider-container--compact {+ padding: 0;+ }++ .slider-track {+ position: relative;+ height: 4px;+ border-radius: 999px;+ background-color: var(--color-gray-20);+ cursor: pointer;+ outline: none;+ }++ .slider-range {+ position: absolute;+ height: 100%;+ border-radius: inherit;+ background-color: var(--color-primary);+ }++ .slider-thumb {+ position: absolute;+ top: 50%;+ width: 12px;+ height: 12px;+ border: 2px solid var(--color-primary);+ border-radius: 50%;+ background-color: $oc-white;+ transform: translate(-50%, -50%);+ cursor: grab;+ box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);+ }++ .slider-track:focus-visible .slider-thumb {+ box-shadow:+ 0 0 0 3px rgba($oc-blue-4, 0.25),+ 0 2px 4px rgba(0, 0, 0, 0.1);+ }++ &.slider-container--neutral {.slider-track {- position: relative;- height: 4px;- background-color: var(--color-gray-20);- border-radius: 2px;- cursor: pointer;+ height: 6px;+ background: linear-gradient(+ 90deg,+ rgba($oc-black, 0.08) 0%,+ rgba($oc-black, 0.14) 100%+ );+ box-shadow:+ inset 0 0 0 1px rgba($oc-black, 0.06),+ inset 0 1px 2px rgba($oc-black, 0.04);}+.slider-range {- position: absolute;- height: 100%;- background-color: var(--color-primary);- border-radius: 3px;+ background-color: var(--color-primary);}+.slider-thumb {- position: absolute;- width: 12px;- height: 12px;- background-color: $oc-white;- border: 2px solid var(--color-primary);- border-radius: 50%;- top: 50%;- transform: translate(-50%, -50%);- cursor: grab;- box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1),+ width: 14px;+ height: 14px;+ border-radius: 999px;+ box-shadow: 0 4px 10px rgba($oc-black, 0.14);+ }++ .slider-track:focus-visible .slider-thumb {+ box-shadow:+ 0 0 0 3px rgba($oc-blue-4, 0.25),+ 0 4px 10px rgba($oc-black, 0.14);}+ }}diff --git a/packages/drawnix/src/components/size-slider.tsx b/packages/drawnix/src/components/size-slider.tsxindex c3d4f0e..3aade13 100644--- a/packages/drawnix/src/components/size-slider.tsx+++ b/packages/drawnix/src/components/size-slider.tsx@@ -1,14 +1,6 @@-import React, {- useState,- useRef,- useCallback,- useEffect,- useMemo,-} from 'react';-import { toFixed } from '@plait/core';+import React, { useEffect, useRef, useState } from 'react';import './size-slider.scss';import classNames from 'classnames';-import { throttle } from 'lodash';interface SliderProps {min?: number;@@ -17,11 +9,23 @@ interface SliderProps {defaultValue?: number;disabled?: boolean;title?: string;+ variant?: 'default' | 'neutral';+ compact?: boolean;onChange?: (value: number) => void;beforeStart?: () => void;afterEnd?: () => void;}+const clamp = (value: number, min: number, max: number) => {+ return Math.min(max, Math.max(min, value));+};++const getStepPrecision = (step: number) => {+ const stepText = step.toString();+ const decimalIndex = stepText.indexOf('.');+ return decimalIndex === -1 ? 0 : stepText.length - decimalIndex - 1;+};+export const SizeSlider: React.FC<SliderProps> = ({min = 0,max = 100,@@ -32,85 +36,112 @@ export const SizeSlider: React.FC<SliderProps> = ({beforeStart,afterEnd,title,+ variant = 'default',+ compact = false,}) => {const [isDragging, setIsDragging] = useState(false);const [value, setValue] = useState(defaultValue);const sliderRef = useRef<HTMLDivElement>(null);- const thumbRef = useRef<HTMLDivElement>(null);+ const precision = getStepPrecision(step);const percentage = ((value - min) / (max - min)) * 100;- const handleSliderChange = useCallback(- throttle(- (event: React.MouseEvent<HTMLDivElement> | MouseEvent) => {- if (sliderRef.current && thumbRef.current) {- const sliderRect = sliderRef.current.getBoundingClientRect();- const thumbRect = thumbRef.current.getBoundingClientRect();- const x = event.clientX - sliderRect.left;- const thumbPercentage = toFixed(- (thumbRect.width / 2 / sliderRect.width) * 100- );- let percentage = Math.min(Math.max(x / sliderRect.width, 0), 1);- if (percentage >= (100 - thumbPercentage) / 100) {- percentage = 1;- } else if (percentage <= thumbPercentage / 100) {- percentage = 0;- }- const newValue =- Math.round((percentage * (max - min)) / step) * step + min;- setValue(newValue);- onChange && onChange(newValue);- }- },- 50,- { leading: true, trailing: true }- ),- [min, max, step, onChange]- );+ useEffect(() => {+ setValue(defaultValue);+ }, [defaultValue]);- const handlePointerDown = useCallback(() => {- const handleMouseMove = (e: MouseEvent) => {- setIsDragging(true);- handleSliderChange(e);- };- const handleMouseUp = () => {- document.removeEventListener('pointermove', handleMouseMove);- document.removeEventListener('pointerup', handleMouseUp);- afterEnd && afterEnd();- setTimeout(() => {- setIsDragging(false);- }, 0);- };+ const updateValue = (nextValue: number) => {+ const roundedValue = Number(+ (+ Math.round((nextValue - min) / step) * step + min+ ).toFixed(precision)+ );+ const normalizedValue = clamp(roundedValue, min, max);+ setValue(normalizedValue);+ onChange?.(normalizedValue);+ };- document.addEventListener('pointermove', handleMouseMove);- document.addEventListener('pointerup', handleMouseUp);- }, [handleSliderChange]);+ const updateValueByClientX = (clientX: number) => {+ if (!sliderRef.current) {+ return;+ }+ const sliderRect = sliderRef.current.getBoundingClientRect();+ const ratio = clamp((clientX - sliderRect.left) / sliderRect.width, 0, 1);+ updateValue(min + ratio * (max - min));+ };- useEffect(()=>{- setValue(defaultValue)- },[defaultValue])+ const finishDragging = (currentTarget: HTMLDivElement, pointerId: number) => {+ if (currentTarget.hasPointerCapture(pointerId)) {+ currentTarget.releasePointerCapture(pointerId);+ }+ setIsDragging(false);+ afterEnd?.();+ };return (<divdata-tooltiptitle={title}- className={classNames('slider-container', { disabled: disabled })}+ className={classNames('slider-container', {+ disabled,+ 'slider-container--neutral': variant === 'neutral',+ 'slider-container--compact': compact,+ })}><divref={sliderRef}className="slider-track"- onClick={(event) => {- if (disabled || isDragging) {+ role="slider"+ tabIndex={disabled ? -1 : 0}+ aria-valuemin={min}+ aria-valuemax={max}+ aria-valuenow={value}+ aria-valuetext={title || String(value)}+ onPointerDown={(event) => {+ event.preventDefault();+ if (disabled) {return;}- handleSliderChange(event);+ beforeStart?.();+ event.currentTarget.setPointerCapture(event.pointerId);+ setIsDragging(true);+ updateValueByClientX(event.clientX);}}- onPointerDown={(event) => {+ onPointerMove={(event) => {+ if (!isDragging || disabled) {+ return;+ }event.preventDefault();+ updateValueByClientX(event.clientX);+ }}+ onPointerUp={(event) => {+ finishDragging(event.currentTarget, event.pointerId);+ }}+ onPointerCancel={(event) => {+ finishDragging(event.currentTarget, event.pointerId);+ }}+ onKeyDown={(event) => {if (disabled) {return;}- beforeStart && beforeStart();- handlePointerDown();+ let nextValue = value;++ if (event.key === 'ArrowLeft' || event.key === 'ArrowDown') {+ nextValue = value - step;+ }+ if (event.key === 'ArrowRight' || event.key === 'ArrowUp') {+ nextValue = value + step;+ }+ if (event.key === 'Home') {+ nextValue = min;+ }+ if (event.key === 'End') {+ nextValue = max;+ }++ if (nextValue !== value) {+ event.preventDefault();+ updateValue(nextValue);+ }}}><div@@ -120,7 +151,6 @@ export const SizeSlider: React.FC<SliderProps> = ({}}/><div- ref={thumbRef}className="slider-thumb"style={{left: `${percentage}%`,diff --git a/packages/drawnix/src/components/toolbar/creation-toolbar.tsx b/packages/drawnix/src/components/toolbar/creation-toolbar.tsxindex fe05144..e7697a5 100644--- a/packages/drawnix/src/components/toolbar/creation-toolbar.tsx+++ b/packages/drawnix/src/components/toolbar/creation-toolbar.tsx@@ -8,7 +8,6 @@ import {SelectionIcon,ShapeIcon,TextIcon,- EraseIcon,StraightArrowLineIcon,FeltTipPenIcon,ImageIcon,@@ -132,7 +131,7 @@ export const isShapePointer = (board: PlaitBoard) => {export const CreationToolbar = () => {const board = useBoard();- const { appState } = useDrawnix();+ const { appState, setAppState } = useDrawnix();const { t } = useI18n();const setPointer = useSetPointer();const container = PlaitBoard.getBoardContainer(board);@@ -142,14 +141,14 @@ export const CreationToolbar = () => {const [shapeOpen, setShapeOpen] = useState(false);const [lastFreehandButton, setLastFreehandButton] =useState<AppToolButtonProps>(- BUTTONS.find((button) => button.key === PopupKey.freehand)!+ BUTTONS.find((button) => button.key === PopupKey.freehand) || BUTTONS[4]);- const [lastShapePointer, setLastShapePointer] = useState<DrawPointerType>(- SHAPES[0].pointer- );- const [lastArrowPointer, setLastArrowPointer] = useState<DrawPointerType>(- ARROWS[0].pointer- );+ const [lastShapePointer, setLastShapePointer] = useState<+ DrawPointerType | undefined+ >(SHAPES[0].pointer);+ const [lastArrowPointer, setLastArrowPointer] = useState<+ DrawPointerType | undefined+ >(ARROWS[0].pointer);const onPointerDown = (pointer: DrawnixPointerType) => {setCreationMode(board, BoardCreationMode.dnd);@@ -169,11 +168,28 @@ export const CreationToolbar = () => {const checkCurrentPointerIsFreehand = (board: PlaitBoard) => {return PlaitBoard.isInPointer(board, [- FreehandShape.feltTipPen,+ FreehandShape.feltTipPen,FreehandShape.eraser,]);};+ const updateFreehandSettings = (+ presetIndex: number,+ nextSettings: Partial<(typeof appState)['freehandPresets'][number]>+ ) => {+ setAppState((currentAppState) => ({+ ...currentAppState,+ freehandPresets: currentAppState.freehandPresets.map((preset, index) => {+ if (index !== presetIndex) {+ return preset;+ }+ return {+ ...preset,+ ...nextSettings,+ };+ }),+ }));+ };return (<Island@@ -183,7 +199,7 @@ export const CreationToolbar = () => {<Stack.Row gap={1}>{BUTTONS.map((button, index) => {if (appState.isMobile && button.pointer === PlaitPointerType.hand) {- return <></>;+ return null;}if (button.key === PopupKey.freehand) {return (@@ -208,7 +224,9 @@ export const CreationToolbar = () => {aria-label={lastFreehandButton.titleKey ? t(lastFreehandButton.titleKey) : 'Freehand'}onPointerDown={() => {setFreehandOpen(!freehandOpen);- onPointerDown(lastFreehandButton.pointer!);+ if (lastFreehandButton.pointer) {+ onPointerDown(lastFreehandButton.pointer);+ }}}onPointerUp={() => {onPointerUp();@@ -217,18 +235,37 @@ export const CreationToolbar = () => {</PopoverTrigger><PopoverContent container={container}><FreehandPanel+ freehandPresets={appState.freehandPresets}+ activePresetIndex={appState.activeFreehandPresetIndex}+ onPresetSelect={(presetIndex: number) => {+ setAppState((currentAppState) => ({+ ...currentAppState,+ activeFreehandPresetIndex: presetIndex,+ }));+ }}+ onStrokeColorSelect={(+ presetIndex: number,+ strokeColor?: string+ ) => {+ updateFreehandSettings(presetIndex, {+ strokeColor,+ });+ }}+ onStrokeWidthSelect={(+ presetIndex: number,+ strokeWidth: number+ ) => {+ updateFreehandSettings(presetIndex, {+ strokeWidth,+ });+ }}onPointerUp={(pointer: DrawnixPointerType) => {setPointer(pointer);- const matched = FREEHANDS.find(- (item: (typeof FREEHANDS)[number]) =>- item.type === 'tool' && item.pointer === pointer+ const selectedButton = FREEHANDS.find(+ (item) => item.pointer === pointer);- if (matched && matched.type === 'tool') {- setLastFreehandButton({- icon: matched.icon,- pointer: matched.pointer,- titleKey: matched.titleKey,- });+ if (selectedButton) {+ setLastFreehandButton(selectedButton);}}}></FreehandPanel>@@ -263,10 +300,13 @@ export const CreationToolbar = () => {if (isShapePointer(board)) {BoardTransforms.updatePointerType(board, board.pointer);} else {- setPointer(lastShapePointer as DrawnixPointerType);+ setPointer(lastShapePointer || SHAPES[0].pointer);setCreationMode(board, BoardCreationMode.drawing);- BoardTransforms.updatePointerType(board, lastShapePointer);- }+ BoardTransforms.updatePointerType(+ board,+ lastShapePointer || SHAPES[0].pointer+ );+ }}}/></PopoverTrigger>@@ -274,7 +314,7 @@ export const CreationToolbar = () => {<ShapePickeronPointerUp={(pointer: DrawPointerType) => {setShapeOpen(false);- setPointer(pointer as DrawnixPointerType);+ setPointer(pointer);setLastShapePointer(pointer);}}></ShapePicker>@@ -305,9 +345,12 @@ export const CreationToolbar = () => {if (isArrowLinePointer(board)) {BoardTransforms.updatePointerType(board, board.pointer);} else {- setPointer(lastArrowPointer as DrawnixPointerType);- BoardTransforms.updatePointerType(board, lastArrowPointer || ARROWS[0].pointer);- BoardTransforms.updatePointerType(board, lastArrowPointer);+ setCreationMode(board, BoardCreationMode.drawing);+ BoardTransforms.updatePointerType(+ board,+ lastArrowPointer || ARROWS[0].pointer+ );+ setPointer(lastArrowPointer || ARROWS[0].pointer);}}}/>@@ -316,7 +359,7 @@ export const CreationToolbar = () => {<ArrowPickeronPointerUp={(pointer: DrawPointerType) => {setArrowOpen(false);- setPointer(pointer as DrawnixPointerType);+ setPointer(pointer);setLastArrowPointer(pointer);}}></ArrowPicker>diff --git a/packages/drawnix/src/components/toolbar/freehand-panel/freehand-panel.tsx b/packages/drawnix/src/components/toolbar/freehand-panel/freehand-panel.tsxindex 313b65a..a0db557 100644--- a/packages/drawnix/src/components/toolbar/freehand-panel/freehand-panel.tsx+++ b/packages/drawnix/src/components/toolbar/freehand-panel/freehand-panel.tsx@@ -10,16 +10,19 @@ import { DrawnixPointerType } from '../../../hooks/use-drawnix';import { useI18n } from '../../../i18n';import { FreehandShape } from '../../../plugins/freehand/type';import {- FreeHandItems,- FreehandItem,- FreehandPresetItem,- FreehandToolItem,+ FREEHANDS,+ FREEHAND_PRESET_IDS,+ type FreehandPresetId,} from '../../../constants/freehand';import {FreehandStylePresetItem,- FreehandStylePreset,+ type FreehandStylePreset,} from './freehand-style-preset-item';import './freehand-style-preset-item.scss';+import {+ DEFAULT_FREEHAND_PRESETS,+ type FreehandDrawOptions,+} from '../../../plugins/freehand/presets';const FreehandStyleDivider = () => (<span className="freehand-style-divider" aria-hidden="true" />@@ -27,64 +30,55 @@ const FreehandStyleDivider = () => (FreehandStyleDivider.displayName = 'FreehandStyleDivider';-const FIRST_PRESET_ID =- FreeHandItems.find(- (item): item is FreehandPresetItem => item.type === 'preset'- )?.id || '';--const isFreehandPresetItem = (item: FreehandItem): item is FreehandPresetItem =>- item.type === 'preset';--const isFreehandToolItem = (item: FreehandItem): item is FreehandToolItem =>- item.type === 'tool';+const getPresetId = (presetIndex: number): FreehandPresetId | string => {+ return FREEHAND_PRESET_IDS[presetIndex] || `preset-${presetIndex + 1}`;+};-const toPreset = (item: FreehandPresetItem): FreehandStylePreset => ({- id: item.id,- color: item.color,- size: item.size,+const toPreset = (+ presetIndex: number,+ preset: FreehandDrawOptions+): FreehandStylePreset => ({+ id: getPresetId(presetIndex),+ color: preset.strokeColor,+ size: preset.strokeWidth,});-const updatePresetInItems = (- items: FreehandItem[],- presetId: string,- updater: (preset: FreehandPresetItem) => FreehandPresetItem-): FreehandItem[] =>- items.map((item) =>- isFreehandPresetItem(item) && item.id === presetId ? updater(item) : item- );--const getPresetItems = (items: FreehandItem[]): FreehandPresetItem[] =>- items.filter((item): item is FreehandPresetItem =>- isFreehandPresetItem(item)- );-const getToolItems = (items: FreehandItem[]): FreehandToolItem[] =>- items.filter((item): item is FreehandToolItem => isFreehandToolItem(item));-export type FreehandPickerProps = {+ freehandPresets: FreehandDrawOptions[];+ activePresetIndex: number;+ onPresetSelect: (presetIndex: number) => void;+ onStrokeColorSelect: (presetIndex: number, strokeColor?: string) => void;+ onStrokeWidthSelect: (presetIndex: number, strokeWidth: number) => void;onPointerUp: (pointer: DrawnixPointerType) => void;};export const FreehandPanel: React.FC<FreehandPickerProps> = ({+ freehandPresets,+ activePresetIndex,+ onPresetSelect,+ onStrokeColorSelect,+ onStrokeWidthSelect,onPointerUp,}) => {const { t } = useI18n();const board = useBoard();const container = PlaitBoard.getBoardContainer(board);- const [items, setItems] = React.useState<FreehandItem[]>(FreeHandItems);- const [activePresetId, setActivePresetId] =- React.useState<string>(FIRST_PRESET_ID);- const toolItems = getToolItems(items);- const presetItems = getPresetItems(items);+ const presets = freehandPresets.length+ ? freehandPresets+ : DEFAULT_FREEHAND_PRESETS;const showPresets = board.pointer !== FreehandShape.eraser;- const saveAndApplyPreset = (preset: FreehandPresetItem) => {- // do nothing now+ const saveAndApplyPreset = (presetIndex: number) => {+ onPresetSelect(presetIndex);+ setCreationMode(board, BoardCreationMode.drawing);+ BoardTransforms.updatePointerType(board, FreehandShape.feltTipPen);+ onPointerUp(FreehandShape.feltTipPen);};return (<Island padding={1}><Stack.Row gap={1} align="start" className="freehand-style-list">- {toolItems.map((freehand, index) => (+ {FREEHANDS.map((freehand, index) => (<ToolButtonkey={index}className={classNames({ fillable: false })}@@ -105,38 +99,27 @@ export const FreehandPanel: React.FC<FreehandPickerProps> = ({}}/>))}- {showPresets && toolItems.length > 0 && presetItems.length > 0 && (+ {showPresets && FREEHANDS.length > 0 && presets.length > 0 && (<FreehandStyleDivider />)}{showPresets &&- presetItems.map((preset) => (- <FreehandStylePresetItem- key={preset.id}- preset={toPreset(preset)}- selected={activePresetId === preset.id}- container={container}- onSelect={() => {- setActivePresetId(preset.id);- saveAndApplyPreset(preset);- }}- onColorChange={(color) => {- setItems((value) =>- updatePresetInItems(value, preset.id, (item) => ({- ...item,- color,- }))- );- }}- onSizeChange={(size) => {- setItems((value) =>- updatePresetInItems(value, preset.id, (item) => ({- ...item,- size,- }))- );- }}- />- ))}+ presets.map((preset, presetIndex) => (+ <FreehandStylePresetItem+ key={getPresetId(presetIndex)}+ preset={toPreset(presetIndex, preset)}+ selected={activePresetIndex === presetIndex}+ container={container}+ onSelect={() => {+ saveAndApplyPreset(presetIndex);+ }}+ onColorChange={(color) => {+ onStrokeColorSelect(presetIndex, color);+ }}+ onSizeChange={(size) => {+ onStrokeWidthSelect(presetIndex, size);+ }}+ />+ ))}</Stack.Row></Island>);diff --git a/packages/drawnix/src/components/toolbar/freehand-panel/freehand-style-preset-item.tsx b/packages/drawnix/src/components/toolbar/freehand-panel/freehand-style-preset-item.tsxindex 15526e3..71424af 100644--- a/packages/drawnix/src/components/toolbar/freehand-panel/freehand-style-preset-item.tsx+++ b/packages/drawnix/src/components/toolbar/freehand-panel/freehand-style-preset-item.tsx@@ -7,10 +7,22 @@ import Stack from '../../stack';import { SizeSlider } from '../../size-slider';import { useI18n } from '../../../i18n';import { ColorPicker } from '../../color-picker';+import { useBoard } from '@plait-board/react-board';+import { getFreehandDefaultStrokeColor } from '../../../plugins/freehand/utils';+import {+ FREEHAND_STROKE_WIDTH_STEP,+ MAX_FREEHAND_STROKE_WIDTH,+ MIN_FREEHAND_STROKE_WIDTH,+} from '../../../plugins/freehand/type';+import { isNoColor } from '../../../utils/color';++const formatSize = (value: number) => {+ return value.toFixed(2).replace(/\.?0+$/, '');+};export interface FreehandStylePreset {id: string;- color: string;+ color?: string;size: number;}@@ -19,7 +31,7 @@ export interface FreehandStylePresetItemProps {selected: boolean;container: HTMLElement | null;onSelect: () => void;- onColorChange: (color: string) => void;+ onColorChange: (color?: string) => void;onSizeChange: (size: number) => void;}@@ -32,7 +44,10 @@ export const FreehandStylePresetItem: React.FC<FreehandStylePresetItemProps> = (onSizeChange,}) => {const { t } = useI18n();+ const board = useBoard();const [open, setOpen] = React.useState(false);+ const swatchColor =+ preset.color || getFreehandDefaultStrokeColor(board.theme.themeColorMode);React.useEffect(() => {if (!selected) {@@ -73,13 +88,13 @@ export const FreehandStylePresetItem: React.FC<FreehandStylePresetItemProps> = (<spanclassName="freehand-style-preset__preview"style={{- borderColor: preset.color,+ borderColor: swatchColor,}}><spanclassName="freehand-style-preset__dot"style={{- backgroundColor: preset.color,+ backgroundColor: swatchColor,width: `${Math.min(Math.max(preset.size + 1, 4), 14)}px`,height: `${Math.min(Math.max(preset.size + 1, 4), 14)}px`,}}@@ -91,11 +106,13 @@ export const FreehandStylePresetItem: React.FC<FreehandStylePresetItemProps> = (<Island padding={4} className="freehand-style-setting"><Stack.Col gap={3}><SizeSlider- title={t('popupToolbar.stroke')}- min={1}- max={24}- step={1}+ title={formatSize(preset.size)}+ min={MIN_FREEHAND_STROKE_WIDTH}+ max={MAX_FREEHAND_STROKE_WIDTH}+ step={FREEHAND_STROKE_WIDTH_STEP}defaultValue={preset.size}+ variant="neutral"+ compact={true}onChange={(value) => {onSizeChange(value);}}@@ -104,7 +121,9 @@ export const FreehandStylePresetItem: React.FC<FreehandStylePresetItemProps> = (currentColor={preset.color}hideOpacitySlider={true}onColorChange={(selectedColor: string) => {- onColorChange(selectedColor);+ onColorChange(+ isNoColor(selectedColor) ? undefined : selectedColor+ );}}onOpacityChange={() => {return;diff --git a/packages/drawnix/src/constants/freehand.ts b/packages/drawnix/src/constants/freehand.tsindex 0753bce..6cdab0c 100644--- a/packages/drawnix/src/constants/freehand.ts+++ b/packages/drawnix/src/constants/freehand.ts@@ -1,70 +1,31 @@-import { CLASSIC_COLORS } from './color';import type React from 'react';import { EraseIcon, FeltTipPenIcon } from '../components/icons';import { FreehandShape } from '../plugins/freehand/type';import type { Translations } from '../i18n';-export const DEFAULT_FREEHAND_PRESET_SIZES = {- preset1: 2,- preset2: 6,- preset3: 10,-} as const;+export const FREEHAND_PRESET_IDS = [+ 'preset-1',+ 'preset-2',+ 'preset-3',+] as const;++export type FreehandPresetId = (typeof FREEHAND_PRESET_IDS)[number];export type FreehandToolItem = {- type: 'tool';titleKey: keyof Translations;icon: React.ReactNode;pointer: FreehandShape.feltTipPen | FreehandShape.eraser;};-export type FreehandPresetItem = {- type: 'preset';- id: string;- color: string;- size: number;-};--export type FreehandItem = FreehandToolItem | FreehandPresetItem;--const getClassicColorValue = (name: string) => {- return CLASSIC_COLORS.find((item) => item.name === name)?.value;-};--export const DEFAULT_FREEHAND_PRESETS: FreehandPresetItem[] = [- {- type: 'preset',- id: 'preset-1',- color: getClassicColorValue('color.default') || CLASSIC_COLORS[1].value,- size: DEFAULT_FREEHAND_PRESET_SIZES.preset1,- },+export const FREEHANDS: FreehandToolItem[] = [{- type: 'preset',- id: 'preset-2',- color: getClassicColorValue('color.red') || CLASSIC_COLORS[5].value,- size: DEFAULT_FREEHAND_PRESET_SIZES.preset2,- },- {- type: 'preset',- id: 'preset-3',- color: getClassicColorValue('color.green') || CLASSIC_COLORS[6].value,- size: DEFAULT_FREEHAND_PRESET_SIZES.preset3,- },-];--export const FreeHandItems: FreehandItem[] = [- {- type: 'tool',icon: FeltTipPenIcon,pointer: FreehandShape.feltTipPen,titleKey: 'toolbar.pen',},{- type: 'tool',icon: EraseIcon,pointer: FreehandShape.eraser,titleKey: 'toolbar.eraser',},- ...DEFAULT_FREEHAND_PRESETS,];--export const FREEHANDS = FreeHandItems;diff --git a/packages/drawnix/src/drawnix.tsx b/packages/drawnix/src/drawnix.tsxindex 31ef7f5..ca03c2f 100644--- a/packages/drawnix/src/drawnix.tsx+++ b/packages/drawnix/src/drawnix.tsx@@ -10,7 +10,7 @@ import {ThemeColorMode,Viewport,} from '@plait/core';-import React, { useState, useRef, useEffect } from 'react';+import React, { useState, useRef } from 'react';import { withGroup } from '@plait/common';import { withDraw } from '@plait/draw';import { MindThemeColors, withMind } from '@plait/mind';@@ -40,6 +40,7 @@ import { LinkPopup } from './components/popup/link-popup/link-popup';import { I18nProvider } from './i18n';import { Tutorial } from './components/tutorial';import { LASER_POINTER_CLASS_NAME } from './utils/laser-pointer';+import { DEFAULT_FREEHAND_PRESETS } from './plugins/freehand/presets';export type DrawnixProps = {value: PlaitElement[];@@ -80,6 +81,10 @@ export const Drawnix: React.FC<DrawnixProps> = ({pointer: PlaitPointerType.hand,isMobile: md.mobile() !== null,isPencilMode: false,+ freehandPresets: DEFAULT_FREEHAND_PRESETS.map((preset) => ({+ ...preset,+ })),+ activeFreehandPresetIndex: 0,openDialogType: null,openCleanConfirm: false,};@@ -92,10 +97,10 @@ export const Drawnix: React.FC<DrawnixProps> = ({}const updateAppState = (newAppState: Partial<DrawnixState>) => {- setAppState({- ...appState,+ setAppState((currentAppState) => ({+ ...currentAppState,...newAppState,- });+ }));};const plugins: PlaitPlugin[] = [diff --git a/packages/drawnix/src/hooks/use-drawnix.tsx b/packages/drawnix/src/hooks/use-drawnix.tsxindex 9fdbe93..660d0fe 100644--- a/packages/drawnix/src/hooks/use-drawnix.tsx+++ b/packages/drawnix/src/hooks/use-drawnix.tsx@@ -3,12 +3,18 @@* context whenever changes occur.*/import { PlaitBoard, PlaitPointerType } from '@plait/core';-import { createContext, useContext } from 'react';+import {+ createContext,+ useContext,+ type Dispatch,+ type SetStateAction,+} from 'react';import { MindPointerType } from '@plait/mind';import { DrawPointerType } from '@plait/draw';import { FreehandShape } from '../plugins/freehand/type';import { Editor } from 'slate';import { LinkElement } from '@plait/common';+import { FreehandDrawOptions } from '../plugins/freehand/presets';export enum DialogType {mermaidToDrawnix = 'mermaidToDrawnix',@@ -38,6 +44,8 @@ export type DrawnixState = {pointer: DrawnixPointerType;isMobile: boolean;isPencilMode: boolean;+ freehandPresets: FreehandDrawOptions[];+ activeFreehandPresetIndex: number;openDialogType: DialogType | null;openCleanConfirm: boolean;linkState?: LinkState | null;@@ -45,12 +53,12 @@ export type DrawnixState = {export const DrawnixContext = createContext<{appState: DrawnixState;- setAppState: (appState: DrawnixState) => void;+ setAppState: Dispatch<SetStateAction<DrawnixState>>;} | null>(null);export const useDrawnix = (): {appState: DrawnixState;- setAppState: (appState: DrawnixState) => void;+ setAppState: Dispatch<SetStateAction<DrawnixState>>;} => {const context = useContext(DrawnixContext);@@ -64,8 +72,8 @@ export const useDrawnix = (): {};export const useSetPointer = () => {- const { appState, setAppState } = useDrawnix();+ const { setAppState } = useDrawnix();return (pointer: DrawnixPointerType) => {- setAppState({ ...appState, pointer });+ setAppState((appState) => ({ ...appState, pointer }));};};diff --git a/packages/drawnix/src/plugins/freehand/presets.ts b/packages/drawnix/src/plugins/freehand/presets.tsnew file mode 100644index 0000000..cb03456--- /dev/null+++ b/packages/drawnix/src/plugins/freehand/presets.ts@@ -0,0 +1,49 @@+import { CLASSIC_COLORS } from '../../constants/color';++export const DEFAULT_FREEHAND_STROKE_WIDTH = 2;++export const MIN_FREEHAND_STROKE_WIDTH = 1;++export const MAX_FREEHAND_STROKE_WIDTH = 12;++export const FREEHAND_STROKE_WIDTH_STEP = 0.25;++export type FreehandDrawOptions = {+ strokeColor?: string;+ strokeWidth: number;+};++const getClassicColorValue = (name: string) => {+ return CLASSIC_COLORS.find((item) => item.name === name)?.value;+};++export const DEFAULT_FREEHAND_PRESETS: FreehandDrawOptions[] = [+ {+ strokeWidth: DEFAULT_FREEHAND_STROKE_WIDTH,+ },+ {+ strokeColor: getClassicColorValue('color.red') || CLASSIC_COLORS[5].value,+ strokeWidth: 6,+ },+ {+ strokeColor:+ getClassicColorValue('color.green') || CLASSIC_COLORS[6].value,+ strokeWidth: 10,+ },+];++export const resolveFreehandDrawOptions = (+ drawOptions: Partial<FreehandDrawOptions> = {}+) => {+ const normalizedDrawOptions = {} as Partial<FreehandDrawOptions>;++ if (typeof drawOptions.strokeColor === 'string' && drawOptions.strokeColor) {+ normalizedDrawOptions.strokeColor = drawOptions.strokeColor;+ }++ if (typeof drawOptions.strokeWidth === 'number') {+ normalizedDrawOptions.strokeWidth = drawOptions.strokeWidth;+ }++ return normalizedDrawOptions;+};diff --git a/packages/drawnix/src/plugins/freehand/type.ts b/packages/drawnix/src/plugins/freehand/type.tsindex 3d62a95..d2e8bd2 100644--- a/packages/drawnix/src/plugins/freehand/type.ts+++ b/packages/drawnix/src/plugins/freehand/type.ts@@ -1,6 +1,13 @@import { DEFAULT_COLOR, Point, ThemeColorMode } from '@plait/core';import { PlaitCustomGeometry } from '@plait/draw';+export {+ DEFAULT_FREEHAND_STROKE_WIDTH,+ FREEHAND_STROKE_WIDTH_STEP,+ MAX_FREEHAND_STROKE_WIDTH,+ MIN_FREEHAND_STROKE_WIDTH,+} from './presets';+export const FreehandThemeColors = {[ThemeColorMode.default]: {strokeColor: DEFAULT_COLOR,@@ -41,7 +48,12 @@ export const FREEHAND_TYPE = 'freehand';export type Freehand = PlaitCustomGeometry<typeof FREEHAND_TYPE, Point[], FreehandShape>export const Freehand = {- isFreehand: (value: any): value is Freehand => {- return value.type === FREEHAND_TYPE;+ isFreehand: (value: unknown): value is Freehand => {+ return (+ typeof value === 'object' &&+ value !== null &&+ 'type' in value &&+ value.type === FREEHAND_TYPE+ );},};diff --git a/packages/drawnix/src/plugins/freehand/utils.spec.ts b/packages/drawnix/src/plugins/freehand/utils.spec.tsnew file mode 100644index 0000000..c4c4b68--- /dev/null+++ b/packages/drawnix/src/plugins/freehand/utils.spec.ts@@ -0,0 +1,44 @@+import type * as PresetsModule from './presets';++jest.mock('@plait/core', () => ({+ DEFAULT_COLOR: '#000000',+}));++const { resolveFreehandDrawOptions } =+ jest.requireActual<typeof PresetsModule>('./presets');++describe('freehand utils', () => {+ it('preserves theme-following presets when color is omitted', () => {+ expect(+ resolveFreehandDrawOptions({+ strokeWidth: 2,+ })+ ).toEqual({+ strokeWidth: 2,+ });+ });++ it('keeps explicit stroke presets', () => {+ expect(+ resolveFreehandDrawOptions({+ strokeColor: '#FF4500',+ strokeWidth: 3.25,+ })+ ).toEqual({+ strokeColor: '#FF4500',+ strokeWidth: 3.25,+ });+ });++ it('keeps explicit default-like preset values', () => {+ expect(+ resolveFreehandDrawOptions({+ strokeColor: '#000000',+ strokeWidth: 2,+ })+ ).toEqual({+ strokeColor: '#000000',+ strokeWidth: 2,+ });+ });+});diff --git a/packages/drawnix/src/plugins/freehand/utils.ts b/packages/drawnix/src/plugins/freehand/utils.tsindex 6caf6b7..87b4b35 100644--- a/packages/drawnix/src/plugins/freehand/utils.ts+++ b/packages/drawnix/src/plugins/freehand/utils.ts@@ -11,6 +11,11 @@ import {ThemeColorMode,} from '@plait/core';import { Freehand, FreehandShape, FreehandThemeColors } from './type';+import {+ DEFAULT_FREEHAND_PRESETS,+ type FreehandDrawOptions,+ resolveFreehandDrawOptions,+} from './presets';import {DefaultDrawStyle,isClosedCustomGeometry,@@ -19,19 +24,38 @@ import {isRectangleHitRotatedPoints,} from '@plait/draw';+type FreehandAppState = {+ activeFreehandPresetIndex?: number;+ freehandPresets?: FreehandDrawOptions[];+};+export function getFreehandPointers() {return [FreehandShape.feltTipPen, FreehandShape.eraser];}+export const getFreehandDrawOptions = (board: PlaitBoard) => {+ const appState = (board as PlaitBoard & { appState?: FreehandAppState })+ .appState;+ const activePresetIndex = appState?.activeFreehandPresetIndex || 0;+ const activePreset =+ appState?.freehandPresets?.[activePresetIndex] ||+ DEFAULT_FREEHAND_PRESETS[activePresetIndex] ||+ DEFAULT_FREEHAND_PRESETS[0];++ return resolveFreehandDrawOptions(activePreset);+};+export const createFreehandElement = (shape: FreehandShape,- points: Point[]+ points: Point[],+ drawOptions: Partial<FreehandDrawOptions> = {}): Freehand => {const element: Freehand = {id: idCreator(),type: 'freehand',shape,points,+ ...resolveFreehandDrawOptions(drawOptions),};return element;};diff --git a/packages/drawnix/src/plugins/freehand/with-freehand-create.ts b/packages/drawnix/src/plugins/freehand/with-freehand-create.tsindex b06e068..573b3e8 100644--- a/packages/drawnix/src/plugins/freehand/with-freehand-create.ts+++ b/packages/drawnix/src/plugins/freehand/with-freehand-create.ts@@ -7,7 +7,11 @@ import {toViewBoxPoint,} from '@plait/core';import { isDrawingMode } from '@plait/common';-import { createFreehandElement, getFreehandPointers } from './utils';+import {+ createFreehandElement,+ getFreehandDrawOptions,+ getFreehandPointers,+} from './utils';import { Freehand, FreehandShape } from './type';import { FreehandGenerator } from './freehand.generator';import { FreehandSmoother } from './smoother';@@ -37,10 +41,11 @@ export const withFreehandCreate = (board: PlaitBoard) => {const complete = (cancel?: boolean) => {if (isDrawing) {const pointer = PlaitBoard.getPointer(board) as FreehandShape;+ const drawOptions = getFreehandDrawOptions(board);if (isSnappingStartAndEnd) {points.push(points[0]);}- temporaryElement = createFreehandElement(pointer, points);+ temporaryElement = createFreehandElement(pointer, points, drawOptions);}if (temporaryElement && !cancel) {Transforms.insertNode(board, temporaryElement, [board.children.length]);@@ -102,7 +107,11 @@ export const withFreehandCreate = (board: PlaitBoard) => {);points.push(newPoint);const pointer = PlaitBoard.getPointer(board) as FreehandShape;- temporaryElement = createFreehandElement(pointer, points);+ temporaryElement = createFreehandElement(+ pointer,+ points,+ getFreehandDrawOptions(board)+ );generator.processDrawing(temporaryElement,PlaitBoard.getElementTopHost(board)