@baron1996/klinecharts-runtime 0.2.3 → 0.4.0

package/dist/drawing/projection-service.js

@@ -0,0 +1,523 @@
+import { Temporal } from '@js-temporal/polyfill';
+import { normalizeDecimalValue } from '@baron1996/kline-scene-schema';
+import { DrawingProjectionError, KLineDrawingProjectionPolicy, TimeSeriesDrawingProjectionPolicy, } from '@baron1996/klinecharts-adapter';
+const EPOCH_DATE = Temporal.PlainDate.from('1970-01-01');
+function zoned(timestamp, timezone) {
+    return Temporal.Instant.fromEpochMilliseconds(timestamp).toZonedDateTimeISO(timezone);
+}
+/**
+ * 纯时间桶、22 种几何与反投影核心；不持有 Adapter/引擎，输入输出深拷贝。
+ */
+export class DrawingProjectionService {
+    #klinePolicy = new KLineDrawingProjectionPolicy();
+    #timeSeriesPolicy = new TimeSeriesDrawingProjectionPolicy();
+    addPeriod(timestamp, period, timezone) {
+        const duration = durationLike(period);
+        return zoned(timestamp, timezone).add(duration).epochMilliseconds;
+    }
+    #periodStart(timestamp, period, timezone) {
+        if (period.type === 'second' ||
+            period.type === 'minute' ||
+            period.type === 'hour') {
+            const unitMilliseconds = period.type === 'second'
+                ? 1000
+                : period.type === 'minute'
+                    ? 60_000
+                    : 3_600_000;
+            const bucketSize = unitMilliseconds * period.span;
+            return Math.floor(timestamp / bucketSize) * bucketSize;
+        }
+        const date = zoned(timestamp, timezone).toPlainDate();
+        if (period.type === 'day') {
+            const days = date.since(EPOCH_DATE, { largestUnit: 'day' }).days;
+            const bucket = Math.floor(days / period.span);
+            return dateStart(EPOCH_DATE.add({ days: bucket * period.span }), timezone);
+        }
+        if (period.type === 'week') {
+            const days = date.since(EPOCH_DATE, { largestUnit: 'day' }).days;
+            const bucket = Math.floor(days / (7 * period.span));
+            return dateStart(EPOCH_DATE.add({ days: bucket * 7 * period.span }), timezone);
+        }
+        if (period.type === 'month') {
+            const months = date.since(EPOCH_DATE, { largestUnit: 'month' }).months;
+            const bucket = Math.floor(months / period.span);
+            return dateStart(EPOCH_DATE.add({ months: bucket * period.span }), timezone);
+        }
+        const years = date.since(EPOCH_DATE, { largestUnit: 'year' }).years;
+        const bucket = Math.floor(years / period.span);
+        return dateStart(EPOCH_DATE.add({ years: bucket * period.span }), timezone);
+    }
+    #barRange(timestamp, data, scenePeriod, timezone) {
+        for (let index = 0; index < data.length; index++) {
+            const start = data[index].timestamp;
+            const end = index + 1 < data.length
+                ? data[index + 1].timestamp
+                : this.addPeriod(start, scenePeriod, timezone);
+            if (timestamp >= start && timestamp < end) {
+                return { start, end, dataIndex: index };
+            }
+        }
+        return null;
+    }
+    #projectAnchor(anchor, data, scenePeriod, timezone) {
+        const bar = this.#barRange(anchor.timestamp, data, scenePeriod, timezone);
+        const start = this.#periodStart(anchor.timestamp, anchor.granularity, timezone);
+        const end = this.addPeriod(start, anchor.granularity, timezone);
+        if (bar === null) {
+            return {
+                kind: 'outside-data-range',
+                startTimestamp: start,
+                endTimestamp: end,
+                dataIndex: null,
+            };
+        }
+        if (start === bar.start && end === bar.end) {
+            return {
+                kind: 'exact',
+                startTimestamp: start,
+                endTimestamp: end,
+                dataIndex: bar.dataIndex,
+            };
+        }
+        if (start >= bar.start && end <= bar.end) {
+            return {
+                kind: 'first-child',
+                startTimestamp: start,
+                endTimestamp: end,
+                dataIndex: bar.dataIndex,
+            };
+        }
+        if (start <= bar.start && end >= bar.end) {
+            return {
+                kind: 'containing-interval',
+                startTimestamp: start,
+                endTimestamp: end,
+                dataIndex: bar.dataIndex,
+            };
+        }
+        return {
+            kind: 'outside-data-range',
+            startTimestamp: start,
+            endTimestamp: end,
+            dataIndex: null,
+        };
+    }
+    projectDrawing(input) {
+        const policy = this.#policyFor(input.scene);
+        const binding = policy.resolveAxisBinding({
+            scene: input.scene,
+            drawing: input.drawing,
+            valueAxes: input.valueAxes,
+            path: input.path,
+        });
+        if (binding.scale === 'logarithmic' &&
+            geometryValues(input.drawing).some((value) => value <= 0)) {
+            throw new DrawingProjectionError('VALUE_AXIS_SCALE_UNSUPPORTED', input.path, 'Logarithmic value axes reject non-positive Drawing values.');
+        }
+        const data = input.scene.kind === 'chart'
+            ? input.scene.document.data
+            : input.scene.document.data;
+        const scenePeriod = input.scene.kind === 'chart'
+            ? input.scene.document.period
+            : input.scene.document.period;
+        const timezone = input.scene.kind === 'chart'
+            ? input.scene.document.chart.timezone
+            : input.scene.document.chart.timezone;
+        const anchors = geometryAnchors(input.drawing, scenePeriod).map((entry) => ({
+            timestamp: entry.anchor.timestamp,
+            granularity: structuredClone(entry.anchor.granularity),
+            value: entry.value,
+            bucket: this.#projectAnchor(entry.anchor, data, scenePeriod, timezone),
+        }));
+        const visible = anchors.length === 0 ||
+            anchors.every((anchor) => anchor.bucket.kind !== 'outside-data-range');
+        return {
+            drawing: structuredClone(input.drawing),
+            binding,
+            anchors,
+            visible,
+        };
+    }
+    projectDocument(input) {
+        const drawings = input.drawings.drawings.map((drawing, index) => this.projectDrawing({
+            scene: input.scene,
+            drawing,
+            valueAxes: input.drawings.coordinateSystem.valueAxes,
+            path: `/drawings/${index}`,
+        }));
+        return {
+            scopeKey: input.drawings.scopeKey,
+            timezone: input.drawings.coordinateSystem.timezone,
+            drawings,
+        };
+    }
+    reverseProjectAnchor(input) {
+        const { original, editingScenePeriod, targetTimestamp, data, scenePeriod, timezone } = input;
+        const originalLength = this.addPeriod(original.timestamp, original.granularity, timezone) -
+            original.timestamp;
+        const editingLength = this.addPeriod(original.timestamp, editingScenePeriod, timezone) -
+            original.timestamp;
+        const bar = this.#barRange(targetTimestamp, data, scenePeriod, timezone);
+        if (bar === null) {
+            throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', '/target', 'Target timestamp does not map to a Scene bar interval.');
+        }
+        if (editingLength < originalLength) {
+            return {
+                timestamp: bar.start,
+                granularity: structuredClone(editingScenePeriod),
+            };
+        }
+        if (editingLength === originalLength) {
+            return {
+                timestamp: bar.start,
+                granularity: structuredClone(original.granularity),
+            };
+        }
+        const oldStart = this.#periodStart(original.timestamp, original.granularity, timezone);
+        const newStart = this.#periodStart(targetTimestamp, original.granularity, timezone);
+        const oldEnd = this.addPeriod(oldStart, original.granularity, timezone);
+        const newEnd = this.addPeriod(newStart, original.granularity, timezone);
+        const duration = zoned(original.timestamp, timezone).since(zoned(oldStart, timezone), {
+            largestUnit: original.granularity.type,
+            smallestUnit: 'millisecond',
+            roundingMode: 'trunc',
+        });
+        let candidate = zoned(newStart, timezone).add(duration).epochMilliseconds;
+        let iterations = 0;
+        while (candidate < newStart || candidate >= newEnd) {
+            if (iterations >= 100_000) {
+                throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', '/target', 'Coarse-period reverse projection exceeded 100000 adjustments.');
+            }
+            iterations += 1;
+            if (candidate < newStart) {
+                const next = this.addPeriod(candidate, original.granularity, timezone);
+                if (next >= newEnd) {
+                    throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', '/target', 'Coarse-period reverse projection crossed the far boundary.');
+                }
+                candidate = next;
+            }
+            else {
+                const next = zoned(candidate, timezone)
+                    .subtract(durationLike(original.granularity))
+                    .epochMilliseconds;
+                if (next < newStart) {
+                    throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', '/target', 'Coarse-period reverse projection crossed the near boundary.');
+                }
+                candidate = next;
+            }
+        }
+        return {
+            timestamp: candidate,
+            granularity: structuredClone(original.granularity),
+        };
+    }
+    reverseProjectDrawing(input) {
+        const policy = this.#policyFor(input.scene);
+        const binding = policy.resolveAxisBinding({
+            scene: input.scene,
+            drawing: input.drawing,
+            valueAxes: input.valueAxes,
+            path: input.path,
+        });
+        const data = input.scene.kind === 'chart'
+            ? input.scene.document.data
+            : input.scene.document.data;
+        const scenePeriod = input.scene.kind === 'chart'
+            ? input.scene.document.period
+            : input.scene.document.period;
+        const timezone = input.scene.kind === 'chart'
+            ? input.scene.document.chart.timezone
+            : input.scene.document.chart.timezone;
+        const candidate = structuredClone(input.drawing);
+        const horizontal = input.horizontal;
+        const vertical = input.vertical;
+        if (horizontal !== undefined) {
+            mapTimeAnchors(candidate, scenePeriod, (anchor) => this.reverseProjectAnchor({
+                original: anchor,
+                editingScenePeriod: horizontal.editingScenePeriod,
+                targetTimestamp: horizontal.targetTimestamp,
+                data,
+                scenePeriod,
+                timezone,
+            }));
+        }
+        if (vertical !== undefined) {
+            let valueIndex = 0;
+            mapValueAnchors(candidate, (value) => {
+                const replacement = vertical.values[valueIndex];
+                valueIndex += 1;
+                if (replacement === undefined) {
+                    throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', input.path, 'Vertical edit values must match the Drawing value anchor count.');
+                }
+                return normalizeDecimalValue(replacement, binding.valuePrecision);
+            });
+            if (valueIndex !== vertical.values.length) {
+                throw new DrawingProjectionError('DRAWING_PROJECTION_INVALID', input.path, 'Vertical edit values must match the Drawing value anchor count.');
+            }
+        }
+        return candidate;
+    }
+    #policyFor(scene) {
+        return scene.kind === 'chart'
+            ? this.#klinePolicy
+            : this.#timeSeriesPolicy;
+    }
+}
+function durationLike(period) {
+    switch (period.type) {
+        case 'second':
+            return { seconds: period.span };
+        case 'minute':
+            return { minutes: period.span };
+        case 'hour':
+            return { hours: period.span };
+        case 'day':
+            return { days: period.span };
+        case 'week':
+            return { weeks: period.span };
+        case 'month':
+            return { months: period.span };
+        case 'year':
+            return { years: period.span };
+    }
+}
+function dateStart(date, timezone) {
+    return date
+        .toZonedDateTime({ timeZone: timezone, plainTime: '00:00' })
+        .epochMilliseconds;
+}
+export function geometryAnchors(drawing, defaultGranularity) {
+    const result = [];
+    const add = (anchor, value = null) => {
+        result.push({ anchor, value });
+    };
+    switch (drawing.type) {
+        case 'horizontalStraightLine':
+        case 'priceLine':
+        case 'simpleTag':
+            break;
+        case 'verticalStraightLine':
+            add({
+                timestamp: drawing.geometry.time,
+                granularity: defaultGranularity,
+            });
+            break;
+        case 'horizontalRayLine':
+        case 'horizontalSegment':
+            add({
+                timestamp: drawing.geometry.startTime,
+                granularity: defaultGranularity,
+            }, drawing.geometry.value);
+            add({
+                timestamp: drawing.geometry.endTime,
+                granularity: defaultGranularity,
+            }, drawing.geometry.value);
+            break;
+        case 'verticalRayLine':
+        case 'verticalSegment':
+            add({
+                timestamp: drawing.geometry.time,
+                granularity: defaultGranularity,
+            }, null);
+            break;
+        case 'rayLine':
+        case 'segment':
+        case 'straightLine':
+        case 'fibonacciLine':
+        case 'priceChannelLine':
+        case 'parallelStraightLine':
+        case 'brush':
+            for (const point of drawing.geometry.points) {
+                add({ timestamp: point.timestamp, granularity: point.granularity }, point.value);
+            }
+            break;
+        case 'simpleAnnotation':
+        case 'callout':
+        case 'text':
+        case 'crossLine':
+            add({
+                timestamp: drawing.geometry.point.timestamp,
+                granularity: drawing.geometry.point.granularity,
+            }, drawing.geometry.point.value);
+            break;
+        case 'rectangle':
+        case 'arrow':
+        case 'priceMeasurement':
+            add({
+                timestamp: drawing.geometry.start.timestamp,
+                granularity: drawing.geometry.start.granularity,
+            }, drawing.geometry.start.value);
+            add({
+                timestamp: drawing.geometry.end.timestamp,
+                granularity: drawing.geometry.end.granularity,
+            }, drawing.geometry.end.value);
+            break;
+    }
+    return result;
+}
+function mapTimeAnchors(drawing, defaultGranularity, transform) {
+    switch (drawing.type) {
+        case 'verticalStraightLine':
+            drawing.geometry.time = transform({
+                timestamp: drawing.geometry.time,
+                granularity: defaultGranularity,
+            }).timestamp;
+            break;
+        case 'horizontalRayLine':
+        case 'horizontalSegment':
+            drawing.geometry.startTime = transform({
+                timestamp: drawing.geometry.startTime,
+                granularity: defaultGranularity,
+            }).timestamp;
+            drawing.geometry.endTime = transform({
+                timestamp: drawing.geometry.endTime,
+                granularity: defaultGranularity,
+            }).timestamp;
+            break;
+        case 'verticalRayLine':
+        case 'verticalSegment':
+            drawing.geometry.time = transform({
+                timestamp: drawing.geometry.time,
+                granularity: defaultGranularity,
+            }).timestamp;
+            break;
+        case 'rayLine':
+        case 'segment':
+        case 'straightLine':
+        case 'fibonacciLine':
+        case 'priceChannelLine':
+        case 'parallelStraightLine':
+        case 'brush':
+            for (const point of drawing.geometry.points) {
+                const updated = transform({
+                    timestamp: point.timestamp,
+                    granularity: point.granularity,
+                });
+                point.timestamp = updated.timestamp;
+                point.granularity = updated.granularity;
+            }
+            break;
+        case 'simpleAnnotation':
+        case 'callout':
+        case 'text':
+        case 'crossLine':
+        case 'rectangle':
+        case 'arrow':
+        case 'priceMeasurement': {
+            const point = 'point' in drawing.geometry
+                ? drawing.geometry.point
+                : undefined;
+            if (point !== undefined) {
+                const updated = transform({
+                    timestamp: point.timestamp,
+                    granularity: point.granularity,
+                });
+                point.timestamp = updated.timestamp;
+                point.granularity = updated.granularity;
+            }
+            if ('start' in drawing.geometry) {
+                const updated = transform({
+                    timestamp: drawing.geometry.start.timestamp,
+                    granularity: drawing.geometry.start.granularity,
+                });
+                drawing.geometry.start.timestamp = updated.timestamp;
+                drawing.geometry.start.granularity = updated.granularity;
+                const endUpdated = transform({
+                    timestamp: drawing.geometry.end.timestamp,
+                    granularity: drawing.geometry.end.granularity,
+                });
+                drawing.geometry.end.timestamp = endUpdated.timestamp;
+                drawing.geometry.end.granularity = endUpdated.granularity;
+            }
+            break;
+        }
+        case 'horizontalStraightLine':
+        case 'priceLine':
+        case 'simpleTag':
+            break;
+    }
+}
+function mapValueAnchors(drawing, transform) {
+    switch (drawing.type) {
+        case 'horizontalStraightLine':
+        case 'priceLine':
+        case 'simpleTag':
+            drawing.geometry.value = transform(drawing.geometry.value);
+            break;
+        case 'horizontalRayLine':
+        case 'horizontalSegment':
+            drawing.geometry.value = transform(drawing.geometry.value);
+            break;
+        case 'verticalRayLine':
+        case 'verticalSegment':
+            drawing.geometry.startValue = transform(drawing.geometry.startValue);
+            drawing.geometry.endValue = transform(drawing.geometry.endValue);
+            break;
+        case 'rayLine':
+        case 'segment':
+        case 'straightLine':
+        case 'fibonacciLine':
+        case 'priceChannelLine':
+        case 'parallelStraightLine':
+        case 'brush':
+            for (const point of drawing.geometry.points) {
+                point.value = transform(point.value);
+            }
+            break;
+        case 'simpleAnnotation':
+        case 'callout':
+        case 'text':
+        case 'crossLine':
+            drawing.geometry.point.value = transform(drawing.geometry.point.value);
+            break;
+        case 'rectangle':
+        case 'arrow':
+        case 'priceMeasurement':
+            drawing.geometry.start.value = transform(drawing.geometry.start.value);
+            drawing.geometry.end.value = transform(drawing.geometry.end.value);
+            break;
+        case 'verticalStraightLine':
+            break;
+    }
+}
+function geometryValues(drawing) {
+    const values = [];
+    switch (drawing.type) {
+        case 'horizontalStraightLine':
+        case 'priceLine':
+        case 'simpleTag':
+        case 'horizontalRayLine':
+        case 'horizontalSegment':
+            values.push(drawing.geometry.value);
+            break;
+        case 'verticalRayLine':
+        case 'verticalSegment':
+            values.push(drawing.geometry.startValue, drawing.geometry.endValue);
+            break;
+        case 'rayLine':
+        case 'segment':
+        case 'straightLine':
+        case 'fibonacciLine':
+        case 'priceChannelLine':
+        case 'parallelStraightLine':
+        case 'brush':
+            for (const point of drawing.geometry.points) {
+                values.push(point.value);
+            }
+            break;
+        case 'simpleAnnotation':
+        case 'callout':
+        case 'text':
+        case 'crossLine':
+            values.push(drawing.geometry.point.value);
+            break;
+        case 'rectangle':
+        case 'arrow':
+        case 'priceMeasurement':
+            values.push(drawing.geometry.start.value, drawing.geometry.end.value);
+            break;
+        case 'verticalStraightLine':
+            break;
+    }
+    return values;
+}

package/dist/drawing/runtime-capability-descriptor.d.ts

@@ -0,0 +1,28 @@
+import type { MainSeriesPresentation, ActiveMainSeriesType } from '@baron1996/klinecharts-adapter';
+export interface RuntimeValueAxisCapability {
+    readonly supportedScales: readonly ('linear' | 'logarithmic')[];
+    readonly activeScale: 'linear' | 'logarithmic';
+    readonly mutable: boolean;
+}
+export interface RuntimeExportArtifactCapability {
+    readonly kind: 'chart-scene' | 'drawable-workspace';
+    readonly mediaType: 'application/json';
+    readonly defaultFileName: string;
+}
+export interface MainSeriesPresentationCapability {
+    readonly presentations: readonly MainSeriesPresentation[];
+    readonly activeType: ActiveMainSeriesType;
+    readonly mutable: boolean;
+}
+export interface HostActionDescriptor {
+    readonly actionId: string;
+    readonly label: string;
+}
+export interface RuntimeCapabilityDescriptor {
+    readonly drawingTypes: readonly string[];
+    readonly valueAxis: RuntimeValueAxisCapability;
+    readonly exportArtifact: RuntimeExportArtifactCapability;
+    readonly mainSeriesPresentation: MainSeriesPresentationCapability | null;
+    readonly hostActions: readonly HostActionDescriptor[];
+}
+//# sourceMappingURL=runtime-capability-descriptor.d.ts.map

package/dist/drawing/runtime-capability-descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-capability-descriptor.d.ts","sourceRoot":"","sources":["../../src/drawing/runtime-capability-descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,sBAAsB,EACtB,oBAAoB,EACpB,MAAM,gCAAgC,CAAC;AAExC,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,eAAe,EAAE,SAAS,CAAC,QAAQ,GAAG,aAAa,CAAC,EAAE,CAAC;IAChE,QAAQ,CAAC,WAAW,EAAE,QAAQ,GAAG,aAAa,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,+BAA+B;IAC/C,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,oBAAoB,CAAC;IACpD,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACjC;AAED,MAAM,WAAW,gCAAgC;IAChD,QAAQ,CAAC,aAAa,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC1D,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,2BAA2B;IAC3C,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,0BAA0B,CAAC;IAC/C,QAAQ,CAAC,cAAc,EAAE,+BAA+B,CAAC;IACzD,QAAQ,CAAC,sBAAsB,EAAE,gCAAgC,GAAG,IAAI,CAAC;IACzE,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;CACtD"}

package/dist/drawing/runtime-capability-descriptor.js

@@ -0,0 +1 @@
+export {};

package/dist/drawing/scene-runtime-factory.d.ts

@@ -0,0 +1,15 @@
+import type { ChartScene, DrawableWorkspaceDocument, TimeSeriesScene } from '@baron1996/kline-scene-schema';
+import { type DrawingEnginePort, type DrawingProjectionPolicy } from '@baron1996/klinecharts-adapter';
+export interface SceneRuntimeRegistration {
+    readonly sceneKind: 'chart' | 'time-series';
+    parseScene(value: unknown): ChartScene | TimeSeriesScene;
+    createAdapter(container: HTMLElement, workspace: DrawableWorkspaceDocument): Promise<DrawingEnginePort>;
+    createPolicy(): DrawingProjectionPolicy;
+    readonly defaultTarget: {
+        readonly paneRole: string;
+        readonly yAxisRole: 'primary';
+    };
+}
+export declare function registerSceneRuntime(registration: SceneRuntimeRegistration): void;
+export declare function getSceneRuntime(kind: 'chart' | 'time-series'): SceneRuntimeRegistration;
+//# sourceMappingURL=scene-runtime-factory.d.ts.map

package/dist/drawing/scene-runtime-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-runtime-factory.d.ts","sourceRoot":"","sources":["../../src/drawing/scene-runtime-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,UAAU,EACV,yBAAyB,EACzB,eAAe,EACf,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAKN,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,MAAM,gCAAgC,CAAC;AAExC,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,aAAa,CAAC;IAC5C,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,eAAe,CAAC;IACzD,aAAa,CACZ,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,yBAAyB,GAClC,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC9B,YAAY,IAAI,uBAAuB,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE;QACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;QAC1B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;KAC9B,CAAC;CACF;AAID,wBAAgB,oBAAoB,CACnC,YAAY,EAAE,wBAAwB,GACpC,IAAI,CAEN;AAED,wBAAgB,eAAe,CAC9B,IAAI,EAAE,OAAO,GAAG,aAAa,GAC3B,wBAAwB,CAM1B"}

package/dist/drawing/scene-runtime-factory.js

@@ -0,0 +1,27 @@
+import { parseChartScene, parseTimeSeriesScene } from '@baron1996/kline-scene-schema';
+import { KLineChartsSceneAdapter, KLineDrawingProjectionPolicy, TimeSeriesChartsAdapter, TimeSeriesDrawingProjectionPolicy, } from '@baron1996/klinecharts-adapter';
+const registrations = new Map();
+export function registerSceneRuntime(registration) {
+    registrations.set(registration.sceneKind, registration);
+}
+export function getSceneRuntime(kind) {
+    const registration = registrations.get(kind);
+    if (registration === undefined) {
+        throw new Error(`No Scene Runtime registered for kind: ${kind}.`);
+    }
+    return registration;
+}
+registerSceneRuntime({
+    sceneKind: 'chart',
+    parseScene: (value) => parseChartScene(value),
+    createAdapter: (container, workspace) => KLineChartsSceneAdapter.createWorkspace(container, workspace),
+    createPolicy: () => new KLineDrawingProjectionPolicy(),
+    defaultTarget: { paneRole: 'candle', yAxisRole: 'primary' },
+});
+registerSceneRuntime({
+    sceneKind: 'time-series',
+    parseScene: (value) => parseTimeSeriesScene(value),
+    createAdapter: (container, workspace) => TimeSeriesChartsAdapter.createWorkspace(container, workspace),
+    createPolicy: () => new TimeSeriesDrawingProjectionPolicy(),
+    defaultTarget: { paneRole: 'time-series', yAxisRole: 'primary' },
+});

package/dist/drawing/session-controller.d.ts

@@ -0,0 +1,53 @@
+import type { DrawingDocument, ValueAxis } from '@baron1996/kline-scene-schema';
+import type { DrawingEnginePort, EngineDrawingSnapshot } from '@baron1996/klinecharts-adapter';
+import { DrawingProjectionService, type ProjectionScene } from './projection-service.js';
+import type { WorkspaceRuntimeEvent } from './workspace-events.js';
+export type DrawingSessionState = 'ready' | 'interacting' | 'awaiting-host-confirmation' | 'reprojecting' | 'terminal-error' | 'destroyed';
+export type DrawingSessionErrorCode = 'DRAWING_CHANGE_IN_PROGRESS' | 'DRAWING_CHANGE_HASH_MISMATCH' | 'DRAWING_CHANGE_REJECTED' | 'DRAWING_PROJECTION_INVALID' | 'DRAWABLE_WORKSPACE_RUNTIME_DESTROYED';
+export declare class DrawingSessionError extends Error {
+    readonly code: DrawingSessionErrorCode;
+    readonly path: string;
+    constructor(code: DrawingSessionErrorCode, path: string, message: string);
+}
+export interface DrawingSessionControllerOptions {
+    readonly runtimeId: string;
+    readonly commitMode: 'immediate' | 'host-confirmed';
+    readonly engine: DrawingEnginePort;
+    readonly projectionService: DrawingProjectionService;
+    readonly scene: ProjectionScene;
+    readonly valueAxes: readonly ValueAxis[];
+    readonly target: {
+        readonly paneRole: string;
+        readonly yAxisRole: 'primary';
+    };
+    readonly scopeKey: string;
+    readonly timezone: string;
+    readonly buildDocument: (drawings: readonly EngineDrawingSnapshot[]) => DrawingDocument;
+    readonly emit: (event: WorkspaceRuntimeEvent) => void;
+}
+/**
+ * 场景无关的 Drawing 会话状态机。
+ * 所有变更都走 candidate 校验/投影/展示/确认链；进度事件永不改 confirmed。
+ */
+export declare class DrawingSessionController {
+    #private;
+    constructor(options: DrawingSessionControllerOptions);
+    get state(): DrawingSessionState;
+    get confirmedDrawings(): readonly EngineDrawingSnapshot[];
+    get selectedId(): string | null;
+    restoreConfirmed(drawings: readonly EngineDrawingSnapshot[]): void;
+    startCreate(type: string, options?: {
+        readonly text?: string;
+        readonly id?: string;
+        readonly styles?: EngineDrawingSnapshot['styles'];
+    }): string;
+    updateDrawingStyles(id: string, styles: EngineDrawingSnapshot['styles']): EngineDrawingSnapshot;
+    updateDrawingText(id: string, text: string): EngineDrawingSnapshot;
+    removeDrawing(id: string): boolean;
+    selectDrawing(id: string | null): void;
+    commitDrawingChange(requestId: string, canonicalHash: string): boolean;
+    rejectDrawingChange(requestId: string): boolean;
+    enterTerminalError(code: string, message: string): void;
+    destroy(): void;
+}
+//# sourceMappingURL=session-controller.d.ts.map

package/dist/drawing/session-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-controller.d.ts","sourceRoot":"","sources":["../../src/drawing/session-controller.ts"],"names":[],"mappings":"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"}