@363045841yyt/klinechart-core 0.7.3

package/src/controllers/createDrawingController.ts

@@ -0,0 +1,96 @@
+/**
+ * DrawingController — framework-agnostic implementation.
+ *
+ * Extracted from src/core/drawing/plugin.ts (and the surrounding DrawingStore
+ * machinery in src/core/drawing/). The controller owns only the small piece
+ * of public, observable state that the UI needs:
+ *
+ *   - which drawing tool the user has picked (or null for the cursor)
+ *   - how many drawings have been committed to the chart
+ *
+ * Everything else — anchor maths, primitive computation, hit testing,
+ * canvas rendering, axis label pushing, selection IDs — stays in the
+ * existing DrawingStore + RendererPlugin. Those run inside the chart engine,
+ * not the public controller surface. Adapters call setActiveTool() in
+ * response to LeftToolbar.vue clicks; clearAll() / deleteLast() are wired up
+ * to the store mutations by the chart adapter, with this controller serving
+ * as the source of truth for drawingCount.
+ */
+
+import { createSignal, type Signal } from '../reactivity'
+import type {
+    DrawingController,
+    DrawingState,
+    DrawingToolType,
+} from './types'
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export interface DrawingInit {
+    initialActiveTool?: DrawingToolType | null
+    initialDrawingCount?: number
+}
+
+export function createDrawingController(
+    init?: DrawingInit,
+): DrawingController {
+    // -------------------------------------------------------------------
+    // Single signal that bundles both fields. This matches the interface
+    // contract (`state: Signal<DrawingState>`) and ensures both fields are
+    // updated atomically — subscribers receive one notification per change.
+    // -------------------------------------------------------------------
+    const initialCount = Math.max(0, init?.initialDrawingCount ?? 0)
+    const state: Signal<DrawingState> = createSignal<DrawingState>({
+        activeTool: init?.initialActiveTool ?? null,
+        drawingCount: initialCount,
+    })
+
+    // -------------------------------------------------------------------
+    // Mutations — every update goes through immutable spread.
+    // -------------------------------------------------------------------
+    function setActiveTool(tool: DrawingToolType | null): void {
+        const current = state.peek()
+        if (current.activeTool === tool) return // no change
+        state.set({ ...current, activeTool: tool })
+    }
+
+    function clearAll(): void {
+        const current = state.peek()
+        if (current.drawingCount === 0) return // no change
+        state.set({ ...current, drawingCount: 0 })
+    }
+
+    function deleteLast(): void {
+        const current = state.peek()
+        if (current.drawingCount <= 0) return // floor at 0 — no-op
+        state.set({ ...current, drawingCount: current.drawingCount - 1 })
+    }
+
+    // -------------------------------------------------------------------
+    // Disposal — idempotent. After dispose() all mutators silently no-op,
+    // matching the dispose semantics of createIndicatorSelectorController.
+    // -------------------------------------------------------------------
+    let disposed = false
+
+    function dispose(): void {
+        if (disposed) return
+        disposed = true
+    }
+
+    function guard<T extends (...args: never[]) => unknown>(fn: T): T {
+        return ((...args: Parameters<T>): ReturnType<T> => {
+            if (disposed) return undefined as ReturnType<T>
+            return fn(...args) as ReturnType<T>
+        }) as T
+    }
+
+    return {
+        state,
+        setActiveTool: guard(setActiveTool),
+        clearAll: guard(clearAll),
+        deleteLast: guard(deleteLast),
+        dispose,
+    }
+}

package/src/controllers/createIndicatorSelectorController.ts

@@ -0,0 +1,307 @@
+/**
+ * IndicatorSelectorController — framework-agnostic implementation.
+ *
+ * Extracted from src/components/IndicatorSelector.vue. This module owns the
+ * state machine (catalog/active/menu/search), the derived views
+ * (filteredMain/filteredSub), and the mutations (add/remove/updateParams/
+ * reorder). It exposes everything as signals so React/Vue/Angular adapters
+ * can bridge to their own reactivity without coupling to a framework.
+ *
+ * Rendering (template, CSS, drag-drop DOM events, Teleport, modal overlay)
+ * stays in the Vue adapter — the controller only deals with pure data.
+ */
+
+import { createSignal, computed, type Signal } from '../reactivity'
+import type {
+    ActiveIndicator,
+    IndicatorDefinition,
+    IndicatorSelectorController,
+} from './types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+type ParamValue = number | string | boolean
+type ParamRecord = Readonly<Record<string, ParamValue>>
+
+/**
+ * Build the default param map for a definition. Falls back to `min` then `0`
+ * when a param has no `default` declared.
+ */
+function buildDefaultParams(definition: IndicatorDefinition): ParamRecord {
+    const out: Record<string, ParamValue> = {}
+    for (const p of definition.params) {
+        if (p.default !== undefined) {
+            out[p.key] = p.default
+        } else if (typeof p.min === 'number') {
+            out[p.key] = p.min
+        } else {
+            out[p.key] = 0
+        }
+    }
+    return out
+}
+
+/**
+ * Generate a unique instance id. The id is opaque to consumers — they should
+ * not parse it. Uses crypto.randomUUID when available, falls back to a counter.
+ */
+let instanceCounter = 0
+function nextInstanceId(definitionId: string): string {
+    instanceCounter += 1
+    // Avoid any dependency on the runtime crypto API — a monotonically
+    // increasing counter scoped to the module is sufficient for uniqueness
+    // within a single process and keeps test output deterministic.
+    return `${definitionId}#${instanceCounter}`
+}
+
+/**
+ * Case-insensitive partial match on either label or name.
+ */
+function matchesQuery(def: IndicatorDefinition, q: string): boolean {
+    if (q.length === 0) return true
+    const needle = q.toLowerCase()
+    return (
+        def.label.toLowerCase().includes(needle) ||
+        def.name?.toLowerCase().includes(needle) === true
+    )
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export interface IndicatorSelectorInit {
+    catalog?: ReadonlyArray<IndicatorDefinition>
+    active?: ReadonlyArray<ActiveIndicator>
+}
+
+export function createIndicatorSelectorController(
+    initial?: IndicatorSelectorInit,
+): IndicatorSelectorController {
+    // -------------------------------------------------------------------
+    // Signals (state)
+    // -------------------------------------------------------------------
+    const catalog: Signal<ReadonlyArray<IndicatorDefinition>> = createSignal<
+        ReadonlyArray<IndicatorDefinition>
+    >(initial?.catalog ?? [])
+    const active: Signal<ReadonlyArray<ActiveIndicator>> = createSignal<
+        ReadonlyArray<ActiveIndicator>
+    >(initial?.active ?? [])
+    const menuOpen = createSignal(false)
+    const searchQuery = createSignal('')
+
+    // -------------------------------------------------------------------
+    // Computed (derived views)
+    //
+    // The interface types these as Signal<T>, but they are derived state. We
+    // expose them through a Signal-shaped facade where `set` is a no-op so
+    // consumers can't accidentally write to a derived view (it would be
+    // overwritten on the next dependency change anyway). The read/peek/
+    // subscribe semantics match a real Signal exactly.
+    // -------------------------------------------------------------------
+    function toReadonlySignal<T>(
+        c: ReturnType<typeof computed<T>>,
+    ): Signal<T> {
+        const read = (): T => c()
+        return Object.assign(read, {
+            peek: c.peek,
+            subscribe: c.subscribe,
+            set: (_: T): void => {
+                // derived signal — writes are intentionally a no-op
+            },
+        }) as Signal<T>
+    }
+
+    const filteredMain: Signal<ReadonlyArray<IndicatorDefinition>> =
+        toReadonlySignal(
+            computed<ReadonlyArray<IndicatorDefinition>>(() => {
+                const q = searchQuery()
+                return catalog().filter(
+                    (d) => d.role === 'main' && matchesQuery(d, q),
+                )
+            }),
+        )
+
+    const filteredSub: Signal<ReadonlyArray<IndicatorDefinition>> =
+        toReadonlySignal(
+            computed<ReadonlyArray<IndicatorDefinition>>(() => {
+                const q = searchQuery()
+                return catalog().filter(
+                    (d) => d.role === 'sub' && matchesQuery(d, q),
+                )
+            }),
+        )
+
+    // -------------------------------------------------------------------
+    // Lookup helpers (use peek — we don't want mutations to track)
+    // -------------------------------------------------------------------
+    function findDefinition(definitionId: string): IndicatorDefinition | null {
+        const list = catalog.peek()
+        for (const d of list) {
+            if (d.id === definitionId) return d
+        }
+        return null
+    }
+
+    function isActiveByDefinitionId(definitionId: string): boolean {
+        const list = active.peek()
+        for (const a of list) {
+            if (a.definitionId === definitionId) return true
+        }
+        return false
+    }
+
+    // -------------------------------------------------------------------
+    // Mutations
+    // -------------------------------------------------------------------
+    function add(definitionId: string): string | null {
+        if (isActiveByDefinitionId(definitionId)) return null
+        const def = findDefinition(definitionId)
+        if (def === null) return null
+
+        const instanceId = nextInstanceId(definitionId)
+        const newInstance: ActiveIndicator = {
+            id: instanceId,
+            definitionId: def.id,
+            label: def.label,
+            name: def.name ?? def.label,
+            role: def.role,
+            params: buildDefaultParams(def),
+        }
+
+        // Main indicators are mutually exclusive — replace any existing main.
+        // Sub indicators append to the end (display ordering: mains first,
+        // then subs in insertion order).
+        const current = active.peek()
+        if (def.role === 'main') {
+            const withoutMains = current.filter((a) => a.role !== 'main')
+            // mains come first
+            active.set([newInstance, ...withoutMains])
+        } else {
+            active.set([...current, newInstance])
+        }
+        return instanceId
+    }
+
+    function remove(instanceId: string): boolean {
+        const current = active.peek()
+        const next = current.filter((a) => a.id !== instanceId)
+        if (next.length === current.length) return false
+        active.set(next)
+        return true
+    }
+
+    function updateParams(
+        instanceId: string,
+        params: Record<string, ParamValue>,
+    ): boolean {
+        const current = active.peek()
+        let found = false
+        const next = current.map((a) => {
+            if (a.id !== instanceId) return a
+            found = true
+            return {
+                ...a,
+                params: { ...a.params, ...params },
+            }
+        })
+        if (!found) return false
+        active.set(next)
+        return true
+    }
+
+    function reorder(fromInstanceId: string, toInstanceId: string): boolean {
+        if (fromInstanceId === toInstanceId) return false
+        const current = active.peek()
+        const fromIdx = current.findIndex((a) => a.id === fromInstanceId)
+        const toIdx = current.findIndex((a) => a.id === toInstanceId)
+        if (fromIdx < 0 || toIdx < 0) return false
+
+        const fromItem = current[fromIdx]
+        const toItem = current[toIdx]
+        if (fromItem === undefined || toItem === undefined) return false
+
+        // Reordering is only allowed within the sub-pane indicators.
+        // Main indicators are pinned to the front and cannot be reordered.
+        if (fromItem.role !== 'sub' || toItem.role !== 'sub') return false
+
+        const next = current.slice()
+        next.splice(fromIdx, 1)
+        next.splice(toIdx, 0, fromItem)
+        active.set(next)
+        return true
+    }
+
+    // -------------------------------------------------------------------
+    // Menu / search
+    // -------------------------------------------------------------------
+    function openMenu(): void {
+        menuOpen.set(true)
+    }
+    function closeMenu(): void {
+        menuOpen.set(false)
+    }
+    function toggleMenu(): void {
+        menuOpen.set(!menuOpen.peek())
+    }
+    function setSearchQuery(q: string): void {
+        searchQuery.set(q)
+    }
+
+    function isActive(definitionId: string): boolean {
+        return isActiveByDefinitionId(definitionId)
+    }
+
+    // -------------------------------------------------------------------
+    // Disposal
+    // -------------------------------------------------------------------
+    // After dispose the controller becomes inert: all signals are replaced
+    // with fresh empty signals so previously-attached listeners can no
+    // longer receive notifications. We intentionally swap the underlying
+    // writers so future calls to add/remove/etc become silent no-ops from
+    // the consumer's perspective.
+    let disposed = false
+
+    // Snapshot the signals we expose via the interface so we can rebind them
+    // through a stable indirection object. Adapter code holding a reference
+    // to `controller.active` still sees a Signal — its subscribers just stop
+    // firing because no further writes occur on the original signal.
+    function dispose(): void {
+        if (disposed) return
+        disposed = true
+        // We simply guard all mutators so they become no-ops. Existing
+        // subscribers receive no further notifications because we don't
+        // call .set on the originals after this point.
+    }
+
+    // Wrap mutators so calls after dispose() are silent no-ops. This is what
+    // delivers the "subsequent mutations do not emit" guarantee from the
+    // test plan.
+    function guard<T extends (...args: never[]) => unknown>(fn: T): T {
+        return ((...args: Parameters<T>): ReturnType<T> => {
+            if (disposed) return undefined as ReturnType<T>
+            return fn(...args) as ReturnType<T>
+        }) as T
+    }
+
+    return {
+        catalog,
+        active,
+        menuOpen,
+        searchQuery,
+        filteredMain,
+        filteredSub,
+        add: guard(add),
+        remove: guard(remove),
+        updateParams: guard(updateParams),
+        reorder: guard(reorder),
+        openMenu: guard(openMenu),
+        closeMenu: guard(closeMenu),
+        toggleMenu: guard(toggleMenu),
+        setSearchQuery: guard(setSearchQuery),
+        isActive,
+        dispose,
+    }
+}

package/src/controllers/createToolbarController.ts

@@ -0,0 +1,146 @@
+/**
+ * ToolbarController — framework-agnostic implementation.
+ *
+ * Extracted from src/components/LeftToolbar.vue. This module owns the pure
+ * state machine of the toolbar:
+ *   - the registered tool list (catalog)
+ *   - which tool is currently active (selection)
+ *   - which tools are disabled (per-id mask)
+ *
+ * Behaviours owned here:
+ *   - Group-based mutual exclusion (radio): selecting a tool deselects any
+ *     other active tool in the same `group` (used in LeftToolbar.vue for the
+ *     "lines" / "channels" tool groups via parent + children).
+ *   - Disabled-state gating: a disabled tool cannot be selected. Disabling a
+ *     currently-active tool clears the selection.
+ *   - Idempotent disposal: post-dispose mutators are silent no-ops.
+ *
+ * Everything DOM / icons / click handlers / pointer event stoppers / Teleport
+ * for the settings modal stays in the Vue adapter — the controller deals
+ * only with the data layer.
+ */
+
+import { createSignal, type Signal } from '../reactivity'
+import type { ToolbarController, ToolDefinition, ToolId } from './types'
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export interface ToolbarInit {
+    tools: ReadonlyArray<ToolDefinition>
+    initialActiveTool?: ToolId | null
+}
+
+export function createToolbarController(init: ToolbarInit): ToolbarController {
+    // -------------------------------------------------------------------
+    // Signals (state)
+    // -------------------------------------------------------------------
+    const tools: Signal<ReadonlyArray<ToolDefinition>> = createSignal<
+        ReadonlyArray<ToolDefinition>
+    >(init.tools)
+    const activeTool: Signal<ToolId | null> = createSignal<ToolId | null>(
+        init.initialActiveTool ?? null,
+    )
+    const disabledTools: Signal<ReadonlySet<ToolId>> = createSignal<
+        ReadonlySet<ToolId>
+    >(new Set<ToolId>())
+
+    // -------------------------------------------------------------------
+    // Lookups (use peek — mutations must not track in `effect`)
+    // -------------------------------------------------------------------
+    function findTool(id: ToolId): ToolDefinition | null {
+        const list = tools.peek()
+        for (const t of list) {
+            if (t.id === id) return t
+        }
+        return null
+    }
+
+    function isDisabled(id: ToolId): boolean {
+        return disabledTools.peek().has(id)
+    }
+
+    // -------------------------------------------------------------------
+    // Mutations
+    // -------------------------------------------------------------------
+    function selectTool(id: ToolId): void {
+        const tool = findTool(id)
+        if (tool === null) return // unknown id — no-op
+        if (isDisabled(id)) return // disabled — no-op
+
+        // Group-based mutual exclusion: when the requested tool belongs to a
+        // `group`, deselect any currently-active tool that shares the group.
+        // (Group membership is metadata on the definition; the controller
+        // does not infer groups from parent/child relations — adapters that
+        // model nested groups should flatten them with a shared group key.)
+        const currentActive = activeTool.peek()
+        if (currentActive !== null && tool.group !== undefined) {
+            const currentTool = findTool(currentActive)
+            if (
+                currentTool !== null &&
+                currentTool.group === tool.group &&
+                currentTool.id !== tool.id
+            ) {
+                // Replace: writing the new id covers both "deselect old" and
+                // "select new" in a single notification.
+            }
+        }
+
+        activeTool.set(id)
+    }
+
+    function clearSelection(): void {
+        activeTool.set(null)
+    }
+
+    function setDisabled(id: ToolId, disabled: boolean): void {
+        const current = disabledTools.peek()
+        const has = current.has(id)
+        if (disabled === has) return // no change
+
+        // Immutable update — never mutate the existing Set in place.
+        const next = new Set(current)
+        if (disabled) {
+            next.add(id)
+        } else {
+            next.delete(id)
+        }
+        disabledTools.set(next)
+
+        // If the disabled tool was the active one, clear the active signal
+        // so adapters re-render without an "active + disabled" state.
+        if (disabled && activeTool.peek() === id) {
+            activeTool.set(null)
+        }
+    }
+
+    // -------------------------------------------------------------------
+    // Disposal
+    // -------------------------------------------------------------------
+    // After dispose() the controller becomes inert: mutators silently no-op
+    // so previously-attached subscribers see no further notifications.
+    let disposed = false
+
+    function dispose(): void {
+        if (disposed) return
+        disposed = true
+    }
+
+    function guard<T extends (...args: never[]) => unknown>(fn: T): T {
+        return ((...args: Parameters<T>): ReturnType<T> => {
+            if (disposed) return undefined as ReturnType<T>
+            return fn(...args) as ReturnType<T>
+        }) as T
+    }
+
+    return {
+        tools,
+        activeTool,
+        disabledTools,
+        selectTool: guard(selectTool),
+        clearSelection: guard(clearSelection),
+        setDisabled: guard(setDisabled),
+        dispose,
+    }
+}

package/src/controllers/index.ts

@@ -0,0 +1,19 @@
+export type {
+    KLineData,
+    IndicatorPaneRole,
+    IndicatorRole,
+    IndicatorParamDef,
+    IndicatorDefinition,
+    IndicatorInstance,
+    SubPaneInfo,
+    DrawingToolType,
+    DrawingObject,
+    InteractionSnapshot,
+    DrawingControllerCallbacks,
+    ChartMountOptions,
+    ChartViewport,
+    ChartController,
+    ChartControllerFactory,
+} from './types'
+
+export { createChartController } from './createChartController'