@baron1996/kline-scene-schema 0.2.3 → 0.4.0

package/dist/decimal-normalization.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 仓库唯一精确十进制规范化核心：最接近、恰好半值时远离零，负零统一转正零。
+ * 非法输入抛 RangeError，由调用方映射到各自稳定错误类型。
+ */
+export declare function normalizeDecimalValue(value: number, precision: number): number;
+//# sourceMappingURL=decimal-normalization.d.ts.map

package/dist/decimal-normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal-normalization.d.ts","sourceRoot":"","sources":["../src/decimal-normalization.ts"],"names":[],"mappings":"AAsBA;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CA8B9E"}

package/dist/decimal-normalization.js

@@ -0,0 +1,47 @@
+function toDecimalParts(value) {
+    const [coefficient = '', exponentText] = value.toString().toLowerCase().split('e');
+    const [integer = '', fraction = ''] = coefficient.split('.');
+    return {
+        digits: BigInt(`${integer}${fraction}`),
+        exponent: Number(exponentText ?? 0) - fraction.length,
+    };
+}
+function toDecimalNumber(value, precision, negative) {
+    const digits = value.toString().padStart(precision + 1, '0');
+    const unsigned = precision === 0
+        ? digits
+        : `${digits.slice(0, -precision)}.${digits.slice(-precision)}`;
+    return Number(`${negative ? '-' : ''}${unsigned}`);
+}
+/**
+ * 仓库唯一精确十进制规范化核心：最接近、恰好半值时远离零，负零统一转正零。
+ * 非法输入抛 RangeError，由调用方映射到各自稳定错误类型。
+ */
+export function normalizeDecimalValue(value, precision) {
+    if (!Number.isFinite(value)) {
+        throw new RangeError('Decimal value must be finite.');
+    }
+    if (!Number.isInteger(precision) ||
+        precision < 0 ||
+        precision > 16) {
+        throw new RangeError('Precision must be an integer from 0 through 16.');
+    }
+    const negative = value < 0;
+    const { digits, exponent } = toDecimalParts(Math.abs(value));
+    const scaledExponent = exponent + precision;
+    let rounded;
+    if (scaledExponent >= 0) {
+        rounded = digits * (10n ** BigInt(scaledExponent));
+    }
+    else {
+        const divisor = 10n ** BigInt(-scaledExponent);
+        const quotient = digits / divisor;
+        const remainder = digits % divisor;
+        rounded = quotient + (remainder * 2n >= divisor ? 1n : 0n);
+    }
+    const normalized = toDecimalNumber(rounded, precision, negative);
+    if (!Number.isFinite(normalized)) {
+        throw new RangeError('Normalized decimal value is not finite.');
+    }
+    return Object.is(normalized, -0) ? 0 : normalized;
+}

package/dist/drawable-workspace-canonical-json.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeCanonicalDrawableWorkspace(value: unknown): Uint8Array<ArrayBuffer>;
+export declare function hashCanonicalDrawableWorkspace(value: unknown): Promise<string>;
+//# sourceMappingURL=drawable-workspace-canonical-json.d.ts.map

package/dist/drawable-workspace-canonical-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawable-workspace-canonical-json.d.ts","sourceRoot":"","sources":["../src/drawable-workspace-canonical-json.ts"],"names":[],"mappings":"AAKA,wBAAgB,mCAAmC,CAClD,KAAK,EAAE,OAAO,GACZ,UAAU,CAAC,WAAW,CAAC,CAWzB;AAED,wBAAsB,8BAA8B,CACnD,KAAK,EAAE,OAAO,GACZ,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/drawable-workspace-canonical-json.js

@@ -0,0 +1,15 @@
+import canonicalize from 'canonicalize';
+import { DrawableWorkspaceError } from './drawable-workspace-errors.js';
+import { parseDrawableWorkspaceDocument } from './drawable-workspace-validator.js';
+export function serializeCanonicalDrawableWorkspace(value) {
+    const parsed = parseDrawableWorkspaceDocument(value);
+    const serialized = canonicalize(parsed);
+    if (serialized === undefined) {
+        throw new DrawableWorkspaceError('DRAWABLE_WORKSPACE_SCHEMA_INVALID', '/', 'DrawableWorkspaceDocument could not be serialized.');
+    }
+    return new TextEncoder().encode(serialized);
+}
+export async function hashCanonicalDrawableWorkspace(value) {
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', serializeCanonicalDrawableWorkspace(value));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}

package/dist/drawable-workspace-canonicalize.d.ts

@@ -0,0 +1,3 @@
+import type { DrawableWorkspaceDocument } from './generated/drawable-workspace.js';
+export declare function canonicalizeDrawableWorkspace(workspace: DrawableWorkspaceDocument): DrawableWorkspaceDocument;
+//# sourceMappingURL=drawable-workspace-canonicalize.d.ts.map

package/dist/drawable-workspace-canonicalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawable-workspace-canonicalize.d.ts","sourceRoot":"","sources":["../src/drawable-workspace-canonicalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,yBAAyB,EAEzB,MAAM,mCAAmC,CAAC;AAwB3C,wBAAgB,6BAA6B,CAC5C,SAAS,EAAE,yBAAyB,GAClC,yBAAyB,CAI3B"}

package/dist/drawable-workspace-canonicalize.js

@@ -0,0 +1,19 @@
+function sortWorkspaceJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortWorkspaceJson(item));
+    }
+    if (value !== null && typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            const child = value[key];
+            if (child !== undefined) {
+                sorted[key] = sortWorkspaceJson(child);
+            }
+        }
+        return sorted;
+    }
+    return value;
+}
+export function canonicalizeDrawableWorkspace(workspace) {
+    return sortWorkspaceJson(structuredClone(workspace));
+}

package/dist/drawable-workspace-errors.d.ts

@@ -0,0 +1,14 @@
+import type { DrawingDocumentErrorCode } from './drawing-errors.js';
+export type DrawableWorkspaceErrorCode = 'DRAWABLE_WORKSPACE_SCHEMA_INVALID' | 'DRAWABLE_WORKSPACE_BINDING_MISMATCH' | 'DRAWABLE_WORKSPACE_DOUBLE_AUTHORITY' | 'DRAWABLE_SCENE_KIND_UNSUPPORTED' | DrawingDocumentErrorCode;
+export interface DrawableWorkspaceIssue {
+    readonly code: DrawableWorkspaceErrorCode;
+    readonly path: string;
+    readonly message: string;
+}
+export declare class DrawableWorkspaceError extends Error {
+    readonly code: DrawableWorkspaceErrorCode;
+    readonly path: string;
+    readonly issues: readonly DrawableWorkspaceIssue[];
+    constructor(code: DrawableWorkspaceErrorCode, path: string, message: string, issues?: readonly DrawableWorkspaceIssue[]);
+}
+//# sourceMappingURL=drawable-workspace-errors.d.ts.map

package/dist/drawable-workspace-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawable-workspace-errors.d.ts","sourceRoot":"","sources":["../src/drawable-workspace-errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAEpE,MAAM,MAAM,0BAA0B,GACnC,mCAAmC,GACnC,qCAAqC,GACrC,qCAAqC,GACrC,iCAAiC,GACjC,wBAAwB,CAAC;AAE5B,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,IAAI,EAAE,0BAA0B,CAAC;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAChD,SAAgB,IAAI,EAAE,0BAA0B,CAAC;IACjD,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,MAAM,EAAE,SAAS,sBAAsB,EAAE,CAAC;gBAGzD,IAAI,EAAE,0BAA0B,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,SAAS,sBAAsB,EAAE;CAQ3C"}

package/dist/drawable-workspace-errors.js

@@ -0,0 +1,12 @@
+export class DrawableWorkspaceError extends Error {
+    code;
+    path;
+    issues;
+    constructor(code, path, message, issues) {
+        super(message);
+        this.name = 'DrawableWorkspaceError';
+        this.code = code;
+        this.path = path;
+        this.issues = issues ?? [{ code, path, message }];
+    }
+}

package/dist/drawable-workspace-semantic-validator.d.ts

@@ -0,0 +1,5 @@
+import type { DrawableWorkspaceDocument } from './generated/drawable-workspace.js';
+import { type DrawableWorkspaceIssue } from './drawable-workspace-errors.js';
+export declare function collectWorkspaceSemanticIssues(workspace: DrawableWorkspaceDocument): readonly DrawableWorkspaceIssue[];
+export declare function assertSemanticDrawableWorkspace(workspace: DrawableWorkspaceDocument): void;
+//# sourceMappingURL=drawable-workspace-semantic-validator.d.ts.map

package/dist/drawable-workspace-semantic-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawable-workspace-semantic-validator.d.ts","sourceRoot":"","sources":["../src/drawable-workspace-semantic-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGX,yBAAyB,EAIzB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGN,KAAK,sBAAsB,EAC3B,MAAM,gCAAgC,CAAC;AAoKxC,wBAAgB,8BAA8B,CAC7C,SAAS,EAAE,yBAAyB,GAClC,SAAS,sBAAsB,EAAE,CA2EnC;AAED,wBAAgB,+BAA+B,CAC9C,SAAS,EAAE,yBAAyB,GAClC,IAAI,CAMN"}

package/dist/drawable-workspace-semantic-validator.js

@@ -0,0 +1,127 @@
+import { DrawableWorkspaceError, } from './drawable-workspace-errors.js';
+function issue(code, path, message) {
+    return { code, path, message };
+}
+function sameAxes(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((axis, index) => {
+        const other = right[index];
+        return other !== undefined
+            && axis.paneRole === other.paneRole
+            && axis.yAxisRole === other.yAxisRole
+            && axis.valuePrecision === other.valuePrecision;
+    });
+}
+function indicatorsOf(scene) {
+    return scene.panes.flatMap((pane) => pane.indicators);
+}
+function validateChartBinding(scene, drawings, issues) {
+    const indicators = indicatorsOf(scene);
+    for (let index = 0; index < drawings.drawings.length; index++) {
+        const drawing = drawings.drawings[index];
+        if (drawing === undefined) {
+            continue;
+        }
+        const path = `/drawings/${index}/target`;
+        const target = drawing.target;
+        if (target.yAxisRole !== 'primary') {
+            issues.push(issue('DRAWING_TARGET_INVALID', `${path}/yAxisRole`, 'v1 Workspace drawings only bind the primary y-axis role.'));
+            continue;
+        }
+        if (target.paneRole === 'candle') {
+            const expectedPrecision = scene.symbol.pricePrecision;
+            const axis = drawings.coordinateSystem.valueAxes.find((candidate) => candidate.paneRole === 'candle' &&
+                candidate.yAxisRole === 'primary');
+            if (axis === undefined || axis.valuePrecision !== expectedPrecision) {
+                issues.push(issue('DRAWING_TARGET_INVALID', path, 'Candle target precision must equal symbol.pricePrecision.'));
+            }
+            continue;
+        }
+        if (target.paneRole.startsWith('indicator:')) {
+            const indicatorId = target.paneRole.slice('indicator:'.length);
+            const matches = indicators.filter((indicator) => indicator.id === indicatorId);
+            if (matches.length !== 1) {
+                issues.push(issue('DRAWING_TARGET_INVALID', path, `Indicator target must resolve to exactly one SceneIndicator: ${indicatorId}.`));
+                continue;
+            }
+            const indicator = matches[0];
+            const pane = scene.panes.find((candidate) => candidate.id === indicator.paneId);
+            const primaryAxis = pane?.yAxes.find((axis) => axis.role === 'primary');
+            if (primaryAxis === undefined || indicator.yAxisId !== primaryAxis.id) {
+                issues.push(issue('DRAWING_TARGET_INVALID', path, 'Indicator target must bind the primary axis of its owning Pane.'));
+                continue;
+            }
+            const axis = drawings.coordinateSystem.valueAxes.find((candidate) => candidate.paneRole === target.paneRole &&
+                candidate.yAxisRole === 'primary');
+            if (axis === undefined || axis.valuePrecision !== indicator.precision) {
+                issues.push(issue('DRAWING_TARGET_INVALID', path, 'Indicator target precision must equal the indicator precision.'));
+            }
+            continue;
+        }
+        issues.push(issue('DRAWABLE_SCENE_KIND_UNSUPPORTED', `${path}/paneRole`, `Chart Scene cannot interpret pane role: ${target.paneRole}.`));
+    }
+}
+function validateTimeSeriesBinding(scene, drawings, issues) {
+    const sharedPrecision = scene.series[0]?.precision;
+    const axis = drawings.coordinateSystem.valueAxes.find((candidate) => candidate.paneRole === 'time-series' &&
+        candidate.yAxisRole === 'primary');
+    if (axis === undefined || axis.valuePrecision !== sharedPrecision) {
+        issues.push(issue('DRAWING_TARGET_INVALID', '/binding/valueAxes', 'TimeSeries primary binding precision must equal the shared series precision.'));
+    }
+    for (let index = 0; index < drawings.drawings.length; index++) {
+        const drawing = drawings.drawings[index];
+        if (drawing === undefined) {
+            continue;
+        }
+        const target = drawing.target;
+        if (target.paneRole !== 'time-series' ||
+            target.yAxisRole !== 'primary') {
+            issues.push(issue('DRAWING_TARGET_INVALID', `/drawings/${index}/target`, 'TimeSeries drawings must target time-series / primary.'));
+        }
+    }
+}
+export function collectWorkspaceSemanticIssues(workspace) {
+    const issues = [];
+    const binding = workspace.binding;
+    const drawings = workspace.drawings;
+    if (binding.scopeKey !== drawings.scopeKey) {
+        issues.push(issue('DRAWABLE_WORKSPACE_BINDING_MISMATCH', '/binding/scopeKey', 'Workspace binding scopeKey must equal the DrawingDocument scopeKey.'));
+    }
+    if (binding.timezone !== drawings.coordinateSystem.timezone) {
+        issues.push(issue('DRAWABLE_WORKSPACE_BINDING_MISMATCH', '/binding/timezone', 'Workspace binding timezone must equal the DrawingDocument timezone.'));
+    }
+    if (!sameAxes(binding.valueAxes, drawings.coordinateSystem.valueAxes)) {
+        issues.push(issue('DRAWABLE_WORKSPACE_BINDING_MISMATCH', '/binding/valueAxes', 'Workspace binding valueAxes must exactly equal the DrawingDocument valueAxes.'));
+    }
+    const scene = workspace.scene;
+    if (scene.kind === 'chart') {
+        const document = scene.document;
+        if (document.chart.timezone !== binding.timezone) {
+            issues.push(issue('DRAWABLE_WORKSPACE_BINDING_MISMATCH', '/scene/document/chart/timezone', 'Chart Scene timezone must equal the Workspace binding timezone.'));
+        }
+        if (document.overlays.length > 0) {
+            issues.push(issue('DRAWABLE_WORKSPACE_DOUBLE_AUTHORITY', '/scene/document/overlays', 'Workspace chart Scenes must not carry legacy overlays.'));
+        }
+        validateChartBinding(document, drawings, issues);
+    }
+    else if (scene.kind === 'time-series') {
+        const document = scene.document;
+        if (document.chart.timezone !== binding.timezone) {
+            issues.push(issue('DRAWABLE_WORKSPACE_BINDING_MISMATCH', '/scene/document/chart/timezone', 'TimeSeries Scene timezone must equal the Workspace binding timezone.'));
+        }
+        validateTimeSeriesBinding(document, drawings, issues);
+    }
+    else {
+        issues.push(issue('DRAWABLE_SCENE_KIND_UNSUPPORTED', '/scene/kind', `Unsupported Workspace scene kind: ${String(scene.kind)}.`));
+    }
+    return issues;
+}
+export function assertSemanticDrawableWorkspace(workspace) {
+    const issues = collectWorkspaceSemanticIssues(workspace);
+    const first = issues[0];
+    if (first !== undefined) {
+        throw new DrawableWorkspaceError(first.code, first.path, first.message, issues);
+    }
+}

package/dist/drawable-workspace-validator.d.ts

@@ -0,0 +1,4 @@
+import type { DrawableWorkspaceDocument } from './generated/drawable-workspace.js';
+export declare function parseStructuralDrawableWorkspace(value: unknown): DrawableWorkspaceDocument;
+export declare function parseDrawableWorkspaceDocument(value: unknown): DrawableWorkspaceDocument;
+//# sourceMappingURL=drawable-workspace-validator.d.ts.map

package/dist/drawable-workspace-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawable-workspace-validator.d.ts","sourceRoot":"","sources":["../src/drawable-workspace-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,yBAAyB,EAGzB,MAAM,mCAAmC,CAAC;AA4E3C,wBAAgB,gCAAgC,CAC/C,KAAK,EAAE,OAAO,GACZ,yBAAyB,CA8B3B;AAED,wBAAgB,8BAA8B,CAC7C,KAAK,EAAE,OAAO,GACZ,yBAAyB,CAgB3B"}

package/dist/drawable-workspace-validator.js

@@ -0,0 +1,74 @@
+import { validateDrawableWorkspace as generatedValidator } from './generated/validate-drawable-workspace.js';
+import { canonicalizeDrawableWorkspace } from './drawable-workspace-canonicalize.js';
+import { DrawableWorkspaceError, } from './drawable-workspace-errors.js';
+import { assertSemanticDrawableWorkspace } from './drawable-workspace-semantic-validator.js';
+import { parseChartScene } from './validator.js';
+import { parseTimeSeriesScene } from './time-series-validator.js';
+import { parseDrawingDocument } from './drawing-validator.js';
+const validateStructural = generatedValidator;
+function pointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+function structuralPath(error) {
+    if (error.keyword === 'additionalProperties' &&
+        error.params?.additionalProperty !== undefined) {
+        return `${error.instancePath}/${pointerToken(error.params.additionalProperty)}` || '/';
+    }
+    if (error.keyword === 'required' &&
+        error.params?.missingProperty !== undefined) {
+        return `${error.instancePath}/${pointerToken(error.params.missingProperty)}` || '/';
+    }
+    return error.instancePath || '/';
+}
+function structuralCode(_error) {
+    return 'DRAWABLE_WORKSPACE_SCHEMA_INVALID';
+}
+function isTopLevelStructuralError(error, all) {
+    if (error.keyword === 'oneOf') {
+        return true;
+    }
+    const oneOfPaths = all
+        .filter((candidate) => candidate.keyword === 'oneOf')
+        .map((candidate) => candidate.instancePath);
+    const descendant = oneOfPaths.some((prefix) => error.instancePath.length > prefix.length &&
+        error.instancePath.startsWith(`${prefix}/`));
+    if (!descendant) {
+        return true;
+    }
+    return error.schemaPath.startsWith('#/properties/type/');
+}
+export function parseStructuralDrawableWorkspace(value) {
+    if (!validateStructural(value)) {
+        const all = validateStructural.errors ?? [];
+        const errors = all
+            .filter((error) => isTopLevelStructuralError(error, all))
+            .map((error) => ({
+            code: structuralCode(error),
+            path: structuralPath(error),
+            message: error.message ?? `Schema validation failed at ${error.schemaPath}.`,
+        }))
+            .sort((left, right) => (left.message.includes('exactly one schema in oneOf') ? 1 : 0) -
+            (right.message.includes('exactly one schema in oneOf') ? 1 : 0) ||
+            left.path.localeCompare(right.path));
+        const issues = errors;
+        const first = issues[0] ?? {
+            code: 'DRAWABLE_WORKSPACE_SCHEMA_INVALID',
+            path: '/',
+            message: 'DrawableWorkspaceDocument schema validation failed.',
+        };
+        throw new DrawableWorkspaceError(first.code, first.path, first.message, issues);
+    }
+    return structuredClone(value);
+}
+export function parseDrawableWorkspaceDocument(value) {
+    const structural = parseStructuralDrawableWorkspace(value);
+    if (structural.scene.kind === 'chart') {
+        structural.scene.document = parseChartScene(structural.scene.document);
+    }
+    else {
+        structural.scene.document = parseTimeSeriesScene(structural.scene.document);
+    }
+    structural.drawings = parseDrawingDocument(structural.drawings);
+    assertSemanticDrawableWorkspace(structural);
+    return canonicalizeDrawableWorkspace(structural);
+}

package/dist/drawing-canonical-json.d.ts

@@ -0,0 +1,3 @@
+export declare function serializeCanonicalDrawingDocument(value: unknown): Uint8Array<ArrayBuffer>;
+export declare function hashCanonicalDrawingDocument(value: unknown): Promise<string>;
+//# sourceMappingURL=drawing-canonical-json.d.ts.map

package/dist/drawing-canonical-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-canonical-json.d.ts","sourceRoot":"","sources":["../src/drawing-canonical-json.ts"],"names":[],"mappings":"AAKA,wBAAgB,iCAAiC,CAChD,KAAK,EAAE,OAAO,GACZ,UAAU,CAAC,WAAW,CAAC,CAWzB;AAED,wBAAsB,4BAA4B,CACjD,KAAK,EAAE,OAAO,GACZ,OAAO,CAAC,MAAM,CAAC,CASjB"}

package/dist/drawing-canonical-json.js

@@ -0,0 +1,15 @@
+import canonicalize from 'canonicalize';
+import { DrawingDocumentError } from './drawing-errors.js';
+import { parseDrawingDocument } from './drawing-validator.js';
+export function serializeCanonicalDrawingDocument(value) {
+    const parsed = parseDrawingDocument(value);
+    const serialized = canonicalize(parsed);
+    if (serialized === undefined) {
+        throw new DrawingDocumentError('DRAWING_DOCUMENT_SCHEMA_INVALID', '/', 'DrawingDocument could not be serialized.');
+    }
+    return new TextEncoder().encode(serialized);
+}
+export async function hashCanonicalDrawingDocument(value) {
+    const digest = await globalThis.crypto.subtle.digest('SHA-256', serializeCanonicalDrawingDocument(value));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}

package/dist/drawing-canonicalize.d.ts

@@ -0,0 +1,3 @@
+import type { DrawingDocument } from './generated/drawing-document.js';
+export declare function canonicalizeDrawingDocument(document: DrawingDocument): DrawingDocument;
+//# sourceMappingURL=drawing-canonicalize.d.ts.map

package/dist/drawing-canonicalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-canonicalize.d.ts","sourceRoot":"","sources":["../src/drawing-canonicalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,eAAe,EAEf,MAAM,iCAAiC,CAAC;AAwBzC,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,eAAe,GACvB,eAAe,CAIjB"}

package/dist/drawing-canonicalize.js

@@ -0,0 +1,19 @@
+function sortDrawingJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortDrawingJson(item));
+    }
+    if (value !== null && typeof value === 'object') {
+        const sorted = {};
+        for (const key of Object.keys(value).sort()) {
+            const child = value[key];
+            if (child !== undefined) {
+                sorted[key] = sortDrawingJson(child);
+            }
+        }
+        return sorted;
+    }
+    return value;
+}
+export function canonicalizeDrawingDocument(document) {
+    return sortDrawingJson(structuredClone(document));
+}

package/dist/drawing-errors.d.ts

@@ -0,0 +1,13 @@
+export type DrawingDocumentErrorCode = 'DRAWING_DOCUMENT_SCHEMA_INVALID' | 'DRAWING_DOCUMENT_SEMANTIC_INVALID' | 'DRAWING_DUPLICATE_ID' | 'DRAWING_GEOMETRY_INVALID' | 'DRAWING_TARGET_INVALID';
+export interface DrawingDocumentIssue {
+    readonly code: DrawingDocumentErrorCode;
+    readonly path: string;
+    readonly message: string;
+}
+export declare class DrawingDocumentError extends Error {
+    readonly code: DrawingDocumentErrorCode;
+    readonly path: string;
+    readonly issues: readonly DrawingDocumentIssue[];
+    constructor(code: DrawingDocumentErrorCode, path: string, message: string, issues?: readonly DrawingDocumentIssue[]);
+}
+//# sourceMappingURL=drawing-errors.d.ts.map

package/dist/drawing-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-errors.d.ts","sourceRoot":"","sources":["../src/drawing-errors.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,wBAAwB,GACjC,iCAAiC,GACjC,mCAAmC,GACnC,sBAAsB,GACtB,0BAA0B,GAC1B,wBAAwB,CAAC;AAE5B,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,SAAgB,IAAI,EAAE,wBAAwB,CAAC;IAC/C,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,MAAM,EAAE,SAAS,oBAAoB,EAAE,CAAC;gBAGvD,IAAI,EAAE,wBAAwB,EAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,SAAS,oBAAoB,EAAE;CAQzC"}

package/dist/drawing-errors.js

@@ -0,0 +1,12 @@
+export class DrawingDocumentError extends Error {
+    code;
+    path;
+    issues;
+    constructor(code, path, message, issues) {
+        super(message);
+        this.name = 'DrawingDocumentError';
+        this.code = code;
+        this.path = path;
+        this.issues = issues ?? [{ code, path, message }];
+    }
+}

package/dist/drawing-semantic-validator.d.ts

@@ -0,0 +1,6 @@
+import type { DrawingDocument, ValueAxis } from './generated/drawing-document.js';
+import { type DrawingDocumentIssue } from './drawing-errors.js';
+export declare function collectDrawingSemanticIssues(document: DrawingDocument): readonly DrawingDocumentIssue[];
+export declare function assertSemanticDrawingDocument(document: DrawingDocument): void;
+export type { ValueAxis };
+//# sourceMappingURL=drawing-semantic-validator.d.ts.map

package/dist/drawing-semantic-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-semantic-validator.d.ts","sourceRoot":"","sources":["../src/drawing-semantic-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,eAAe,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC3F,OAAO,EAAuD,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAsKrH,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,eAAe,GACvB,SAAS,oBAAoB,EAAE,CAsBjC;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,CAM7E;AAED,YAAY,EAAE,SAAS,EAAE,CAAC"}

package/dist/drawing-semantic-validator.js

@@ -0,0 +1,123 @@
+import { DrawingDocumentError } from './drawing-errors.js';
+import { normalizeDecimalValue } from './decimal-normalization.js';
+function issue(code, path, message) {
+    return { code, path, message };
+}
+function drawingGeometryValues(drawing, path) {
+    const result = [];
+    const add = (value, valuePath) => {
+        result.push({ path: valuePath, value });
+    };
+    switch (drawing.type) {
+        case 'horizontalStraightLine':
+        case 'priceLine':
+            add(drawing.geometry.value, `${path}/geometry/value`);
+            break;
+        case 'simpleTag':
+            add(drawing.geometry.value, `${path}/geometry/value`);
+            break;
+        case 'verticalStraightLine':
+            break;
+        case 'horizontalRayLine':
+        case 'horizontalSegment':
+            add(drawing.geometry.value, `${path}/geometry/value`);
+            break;
+        case 'verticalRayLine':
+        case 'verticalSegment':
+            add(drawing.geometry.startValue, `${path}/geometry/startValue`);
+            add(drawing.geometry.endValue, `${path}/geometry/endValue`);
+            break;
+        case 'rayLine':
+        case 'segment':
+        case 'straightLine':
+        case 'fibonacciLine':
+        case 'priceChannelLine':
+        case 'parallelStraightLine':
+        case 'brush':
+            for (let index = 0; index < drawing.geometry.points.length; index++) {
+                add(drawing.geometry.points[index].value, `${path}/geometry/points/${index}/value`);
+            }
+            break;
+        case 'simpleAnnotation':
+        case 'callout':
+        case 'text':
+        case 'crossLine':
+            add(drawing.geometry.point.value, `${path}/geometry/point/value`);
+            break;
+        case 'rectangle':
+        case 'arrow':
+        case 'priceMeasurement':
+            add(drawing.geometry.start.value, `${path}/geometry/start/value`);
+            add(drawing.geometry.end.value, `${path}/geometry/end/value`);
+            break;
+    }
+    return result;
+}
+function validateValueAxes(document, issues) {
+    const axes = document.coordinateSystem.valueAxes;
+    for (let index = 0; index < axes.length; index++) {
+        const axis = axes[index];
+        if (axis === undefined) {
+            continue;
+        }
+        const path = `/coordinateSystem/valueAxes/${index}`;
+        if (axis.yAxisRole !== 'primary') {
+            issues.push(issue('DRAWING_TARGET_INVALID', `${path}/yAxisRole`, 'v1 Drawing value axes only allow the primary role.'));
+        }
+        const previous = axes[index - 1];
+        if (previous !== undefined &&
+            (previous.paneRole > axis.paneRole ||
+                (previous.paneRole === axis.paneRole && previous.yAxisRole >= axis.yAxisRole))) {
+            issues.push(issue('DRAWING_DOCUMENT_SEMANTIC_INVALID', path, 'valueAxes must be lexically ascending by paneRole and yAxisRole without duplicates.'));
+        }
+    }
+}
+function validateDrawing(document, drawing, index, issues) {
+    const path = `/drawings/${index}`;
+    const axis = document.coordinateSystem.valueAxes.find((candidate) => candidate.paneRole === drawing.target.paneRole &&
+        candidate.yAxisRole === drawing.target.yAxisRole);
+    if (axis === undefined) {
+        issues.push(issue('DRAWING_TARGET_INVALID', `${path}/target`, 'Drawing target must exactly match one coordinateSystem.valueAxes entry.'));
+        return;
+    }
+    if (drawing.target.yAxisRole !== 'primary') {
+        issues.push(issue('DRAWING_TARGET_INVALID', `${path}/target/yAxisRole`, 'v1 Drawing targets only allow the primary y-axis role.'));
+    }
+    for (const coordinate of drawingGeometryValues(drawing, path)) {
+        let normalized;
+        try {
+            normalized = normalizeDecimalValue(coordinate.value, axis.valuePrecision);
+        }
+        catch (error) {
+            issues.push(issue('DRAWING_GEOMETRY_INVALID', coordinate.path, error instanceof Error ? error.message : 'Value normalization failed.'));
+            continue;
+        }
+        if (normalized !== coordinate.value || Object.is(coordinate.value, -0)) {
+            issues.push(issue('DRAWING_GEOMETRY_INVALID', coordinate.path, `Value must already be normalized to precision ${axis.valuePrecision}.`));
+        }
+    }
+}
+export function collectDrawingSemanticIssues(document) {
+    const issues = [];
+    validateValueAxes(document, issues);
+    const ids = new Set();
+    for (let index = 0; index < document.drawings.length; index++) {
+        const drawing = document.drawings[index];
+        if (drawing === undefined) {
+            continue;
+        }
+        if (ids.has(drawing.id)) {
+            issues.push(issue('DRAWING_DUPLICATE_ID', `/drawings/${index}/id`, `Duplicate drawing ID: ${drawing.id}.`));
+        }
+        ids.add(drawing.id);
+        validateDrawing(document, drawing, index, issues);
+    }
+    return issues;
+}
+export function assertSemanticDrawingDocument(document) {
+    const issues = collectDrawingSemanticIssues(document);
+    const first = issues[0];
+    if (first !== undefined) {
+        throw new DrawingDocumentError(first.code, first.path, first.message, issues);
+    }
+}

package/dist/drawing-validator.d.ts

@@ -0,0 +1,4 @@
+import type { DrawingDocument } from './generated/drawing-document.js';
+export declare function parseStructuralDrawingDocument(value: unknown): DrawingDocument;
+export declare function parseDrawingDocument(value: unknown): DrawingDocument;
+//# sourceMappingURL=drawing-validator.d.ts.map

package/dist/drawing-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-validator.d.ts","sourceRoot":"","sources":["../src/drawing-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AA2EvE,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CA8B9E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAIpE"}