@web-ppt/edit-core 0.5.0-beta.1 → 0.5.0-beta.7

package/dist/chart/shared-xy-family.d.ts

@@ -0,0 +1,16 @@
+import type { SharedGroup } from './shared-graph';
+import type { ChartDatasetState } from './types';
+import type { SharedRecordAxis } from './shared-record-axis';
+import type { SharedXYAxisOwner } from './shared-xy-source';
+export { sharedXYAxis } from './shared-xy-source';
+export type { SharedXYOwner, SharedXYAxisOwner } from './shared-xy-source';
+export interface SharedXYFamily extends SharedRecordAxis {
+    readonly owners: readonly SharedXYAxisOwner[];
+    readonly identities: ReadonlySet<string>;
+    readonly positions: ReadonlySet<number>;
+    readonly anchors: ReadonlySet<number>;
+}
+export declare function sharedXYFamily(shared: SharedGroup, chartId: string, seriesId: string): SharedXYFamily;
+export declare function sharedXYFamilyByKey(shared: SharedGroup, key: string): SharedXYFamily;
+export declare const sharedXYCell: (family: SharedRecordAxis, lane: number, axis: number) => string;
+export declare const xyOwnersForState: (family: SharedXYFamily, state: ChartDatasetState) => SharedXYAxisOwner[];

package/dist/chart/shared-xy-project.d.ts

@@ -0,0 +1,6 @@
+import type { ChartDatasetState } from './types';
+import type { SharedGroup } from './shared-graph';
+import type { XYResource } from './shared-xy-records';
+import type { WorkbookCellValue } from './workbook-read';
+/** 每个视图只取自身来源范围内的插入；共享记录的坐标和身份由整条轴统一决定。 */
+export declare function projectSharedXY(shared: SharedGroup, state: ChartDatasetState, original: ChartDatasetState, resource: XYResource, baseline: ReadonlyMap<string, WorkbookCellValue>): void;

package/dist/chart/shared-xy-records.d.ts

@@ -0,0 +1,23 @@
+import type { DocumentExtensionPatch } from '../commands/types';
+import type { SharedGroup } from './shared-graph';
+import type { SharedXYFamily } from './shared-xy-family';
+import type { InsertedResource } from './shared-inserted-project';
+export interface XYAxisRecords {
+    readonly insertions?: Readonly<Record<string, unknown>>;
+    readonly removed?: Readonly<Record<string, unknown>>;
+}
+export type SharedXYRecords = Readonly<Record<string, XYAxisRecords>>;
+export interface XYResource extends InsertedResource {
+    readonly xyRecords?: SharedXYRecords;
+}
+export declare function validateXYPatch(shared: SharedGroup, patch: DocumentExtensionPatch): void;
+export declare function validateXYRecords(shared: SharedGroup, records: unknown): void;
+export declare function xyRecordLayout(family: SharedXYFamily, records: XYAxisRecords): {
+    key: (lane: number, axis: number) => string;
+    records: readonly import("./shared-inserted-records").InsertedRow[];
+    active: import("./shared-inserted-records").InsertedRow[];
+    deleted: number[];
+    originalAxis: (axis: number) => number;
+    insertedAxis: (row: import("./shared-inserted-records").InsertedRow) => number;
+    end: number;
+};

package/dist/chart/shared-xy-save.d.ts

@@ -0,0 +1,5 @@
+import type { EditDoc } from '../types';
+import type { SharedGroup } from './shared-graph';
+import type { XYResource } from './shared-xy-records';
+import type { WorkbookCellValue } from './workbook-read';
+export declare function writeSharedXY(doc: EditDoc, shared: SharedGroup, resource: XYResource, baseline: ReadonlyMap<string, WorkbookCellValue>, write: (key: string, value: string | number | null) => void): void;

package/dist/chart/shared-xy-source.d.ts

@@ -0,0 +1,39 @@
+import type { SharedGroup } from './shared-graph';
+import type { ChartDatasetState, ChartPointId, ChartSeriesId } from './types';
+export interface SharedXYOwner {
+    readonly chart: SharedGroup['charts'][number];
+    readonly seriesId: ChartSeriesId;
+    readonly references: ReadonlySet<string>;
+}
+export interface SharedXYAxisOwner extends SharedXYOwner {
+    readonly positions: ReadonlyMap<ChartPointId, number>;
+    readonly lanes: ReadonlyMap<'x' | 'value' | 'size', number>;
+    readonly start: number;
+    readonly end: number;
+}
+export declare function xyOwners(shared: SharedGroup): SharedXYOwner[];
+/** 空缓存和已保存的系列模板仍可从各维度位置恢复方向，不依赖活跃消费者集合。 */
+export declare function sharedXYAxis(series: ChartDatasetState['series'][ChartSeriesId]): {
+    sheet: string;
+    horizontal: boolean;
+};
+export declare function connectedXYOwners(shared: SharedGroup, chartId: string, seriesId: string): {
+    target: SharedXYOwner;
+    selected: Set<SharedXYOwner>;
+    references: Set<string>;
+};
+export declare function xyAxisOwners(owners: readonly SharedXYOwner[], sheet: string, horizontal: boolean): {
+    members: {
+        positions: Map<ChartPointId, number>;
+        lanes: Map<"size" | "x" | "value", number>;
+        start: number;
+        end: number;
+        chart: SharedGroup["charts"][number];
+        seriesId: ChartSeriesId;
+        references: ReadonlySet<string>;
+    }[];
+    keys: Set<string>;
+    lanes: Set<number>;
+    axes: Set<number>;
+    anchors: Set<number>;
+};

package/dist/chart/shared.d.ts

@@ -0,0 +1,13 @@
+import type { EditDoc, ElementId } from '../types';
+import type { CommandPatches, DocumentExtensionPatch } from '../commands/types';
+import type { ChartDatasetState } from './types';
+import type { SharedGroup } from './shared-graph';
+export type { SharedGroup } from './shared-graph';
+export declare const ownsSharedChart: (doc: EditDoc, id: ElementId) => boolean;
+/** 单元格覆盖只有一份，图表缓存始终由同一份覆盖投影，避免并发编辑留下两套真值。 */
+export declare function sharedDatasetState(doc: EditDoc, id: ElementId, state: ChartDatasetState): ChartDatasetState;
+export declare function projectSharedDataset(doc: EditDoc, shared: SharedGroup, state: ChartDatasetState): ChartDatasetState;
+export declare function sharedCommandPatches(doc: EditDoc, id: ElementId, local: CommandPatches, origin: string): CommandPatches;
+export declare function sharedChartElements(doc: EditDoc, patch?: DocumentExtensionPatch): ElementId[];
+export declare function validateSharedChartPatch(doc: EditDoc, patch: DocumentExtensionPatch): void;
+export declare function validateSharedDocument(doc: EditDoc): void;

package/dist/chart/source.d.ts

@@ -0,0 +1,11 @@
+import type { EditDoc, ElementId } from '../types';
+import type { ChartDataset, ChartDatasetState } from './types';
+export declare const currentChartDatasetState: (doc: EditDoc, id: ElementId) => ChartDatasetState;
+export declare const chartDatasetStatesEqual: (left: ChartDatasetState, right: ChartDatasetState) => boolean;
+export declare function chartStateMatchesSource(doc: EditDoc, id: ElementId): boolean;
+export declare function chartStateHasEffectiveChanges(doc: EditDoc, id: ElementId): boolean;
+export declare function readChartDataset(doc: EditDoc, id: ElementId): ChartDataset;
+export declare function hydrateChartDataset(doc: EditDoc, id: ElementId, deferWorkbookPlanning?: boolean): ChartDatasetState;
+export declare const NATIVE_CHART_ID = "shared-native";
+export declare function hydrateChartPart(doc: EditDoc, part: string): ChartDatasetState;
+export declare function chartRecordIds(doc: EditDoc): ElementId[];

package/dist/chart/types.d.ts

@@ -0,0 +1,86 @@
+import type { ElementId, FractionalIndex } from '../types';
+export type ChartSeriesId = string & {
+    readonly __chartSeriesId: unique symbol;
+};
+export type ChartPointId = string & {
+    readonly __chartPointId: unique symbol;
+};
+export type ChartPlotKind = 'bar' | 'line' | 'pie' | 'doughnut' | 'area' | 'scatter' | 'radar' | 'bubble' | 'stock' | 'ofPie' | 'surface' | 'other';
+export interface ChartFormulaBinding {
+    readonly formula: string | null;
+    readonly cache: 'number' | 'string' | 'literal' | 'missing';
+    readonly hierarchy?: {
+        readonly levels: number;
+        readonly orientation: 'rows' | 'columns';
+    };
+}
+export interface ChartDataBinding {
+    readonly chartPart: string;
+    readonly workbookPart: string | null;
+    readonly mode: 'workbook' | 'cache' | 'readonly';
+    readonly reason?: string;
+    /** 旧编辑或共享覆盖无法解释时，不返回可被误认为当前数据的来源缓存。 */
+    readonly unresolved?: true;
+}
+export interface ChartCategory {
+    readonly id: ChartPointId;
+    readonly order: FractionalIndex;
+    readonly label: string;
+    /** 从根到叶的原生槽位；父级 null 延续组，叶级 null 是缺失标签，空字符串是显式空值。 */
+    readonly levels?: readonly (string | null)[];
+    readonly removed?: true;
+}
+export interface ChartPoint {
+    readonly id: ChartPointId;
+    readonly order: FractionalIndex;
+    readonly value: number | null;
+    readonly x?: number | null;
+    readonly size?: number | null;
+    readonly removed?: true;
+}
+export interface ChartSeries {
+    readonly id: ChartSeriesId;
+    readonly order: FractionalIndex;
+    readonly sourceIndex: number;
+    readonly plotKind: ChartPlotKind;
+    readonly name: string;
+    readonly points: readonly ChartPoint[];
+    readonly bindings: {
+        readonly name: ChartFormulaBinding;
+        readonly categories?: ChartFormulaBinding;
+        readonly values?: ChartFormulaBinding;
+        readonly x?: ChartFormulaBinding;
+        readonly y?: ChartFormulaBinding;
+        readonly size?: ChartFormulaBinding;
+    };
+    readonly removed?: true;
+}
+export interface ChartDataset {
+    readonly chartId: ElementId;
+    readonly kind: 'category' | 'xy' | 'mixed';
+    /** 来源绘图区能安全复用的系列类型；删空后仍可据此重建。 */
+    readonly plotKinds: readonly ChartPlotKind[];
+    readonly categories: readonly ChartCategory[];
+    readonly series: readonly ChartSeries[];
+    readonly binding: ChartDataBinding;
+}
+export interface EditableChart {
+    readonly id: ElementId;
+    readonly name: string;
+    readonly binding: ChartDataBinding;
+}
+export interface ChartDatasetState {
+    kind: ChartDataset['kind'];
+    binding: ChartDataBinding;
+    categories: Record<ChartPointId, ChartCategory & {
+        /** 新增类别创建时的前驱；墓碑保留分组，但不能让后来新增的类别复活已删除的组。 */
+        levelParent?: ChartPointId | null;
+        /** 清空组首时接受的前驱；后续删除前驱也不能改变已经选择的分组。 */
+        levelClears?: Readonly<Record<string, ChartPointId | null>>;
+    }>;
+    series: Record<ChartSeriesId, Omit<ChartSeries, 'points'> & {
+        points: Record<ChartPointId, ChartPoint>;
+        /** 仅表示 wppt 持久模板；其公式必须先按未受信来源通过工作簿占用检查。 */
+        sourceTemplate?: true;
+    }>;
+}

package/dist/chart/validation.d.ts

@@ -0,0 +1,24 @@
+import type { FractionalIndex } from '../types';
+import type { ChartCategory, ChartPlotKind, ChartPoint, ChartSeries, ChartSeriesId } from './types';
+export { MAX_CHART_NAME, MAX_CHART_IDENTITY, MAX_CHART_POINTS, MAX_CHART_SERIES, MAX_CHART_CELLS } from './limits';
+export declare const CHART_PLOT_KINDS: Set<ChartPlotKind>;
+export declare function assertChartName(value: unknown, label: string): asserts value is string;
+export declare function assertChartNumber(value: unknown, label: string): asserts value is number | null;
+export declare function assertChartDictionary(value: unknown, label: string): asserts value is Record<string, unknown>;
+export declare function assertChartRecord(value: unknown, keys: readonly string[], label: string): asserts value is Record<string, unknown>;
+export declare function assertChartIdentity(value: unknown, expected: string, label: string): asserts value is string;
+export declare function assertChartOrder(value: unknown, label: string): asserts value is FractionalIndex;
+export declare function assertChartPointRecord(value: unknown, expectedId: string, label: string): asserts value is ChartPoint;
+export declare function assertChartCategoryRecord(value: unknown, expectedId: string, label: string): asserts value is ChartCategory;
+export declare function assertCategoryLevels(value: unknown, depth?: number): asserts value is readonly (string | null)[];
+export declare function assertChartSeriesRecord(value: unknown, expectedId: string, label: string, literalOnly?: boolean): asserts value is Omit<ChartSeries, 'points'> & {
+    points: Record<string, ChartPoint>;
+};
+type StoredSeries = Omit<ChartSeries, 'points'> & {
+    points: Record<string, ChartPoint>;
+    sourceTemplate?: true;
+};
+export declare function validateMaterializedRecords(categories: Record<string, ChartCategory>, series: Record<ChartSeriesId, Omit<ChartSeries, 'points'> & {
+    points: Record<string, ChartPoint>;
+    sourceTemplate?: true;
+}>, sourceCategories: Readonly<Record<string, ChartCategory>>, sourceSeries: Readonly<Record<string, StoredSeries>>): boolean;

package/dist/chart/workbook-range.d.ts

@@ -0,0 +1,16 @@
+export declare function addressParts(address: string): {
+    column: number;
+    row: number;
+};
+export declare function worksheetRangeBounds(reference: string): {
+    readonly start: {
+        column: number;
+        row: number;
+    };
+    readonly end: {
+        column: number;
+        row: number;
+    };
+};
+export declare function worksheetRangeCells(reference: string): string[];
+export declare function rangeCells(formula: string | null): string[];

package/dist/chart/workbook-read.d.ts

@@ -0,0 +1,7 @@
+import type { WorkbookMap } from './workbook';
+export interface WorkbookCellValue {
+    readonly kind: 'number' | 'string' | 'blank' | 'unsupported';
+    readonly value: string | number | null;
+}
+export declare const workbookCellKey: (sheet: string, address: string) => string;
+export declare function readWorkbookCells(parts: Readonly<Record<string, Uint8Array>>, map: WorkbookMap): Map<string, WorkbookCellValue>;

package/dist/chart/workbook-write.d.ts

@@ -0,0 +1,9 @@
+import type { ChartDatasetState } from './types';
+import type { WorkbookMap } from './workbook';
+type CellValue = {
+    readonly kind: 'string' | 'number';
+    readonly value: string | number | null;
+};
+export declare function writeChartWorkbook(sourceBytes: Uint8Array, parts: Readonly<Record<string, Uint8Array>>, map: WorkbookMap, source: ChartDatasetState, planned: ChartDatasetState): Uint8Array;
+export declare function writeWorkbookCells(sourceBytes: Uint8Array, parts: Readonly<Record<string, Uint8Array>>, map: WorkbookMap, writes: ReadonlyMap<string, ReadonlyMap<string, CellValue>>): Uint8Array;
+export {};

package/dist/chart/workbook.d.ts

@@ -0,0 +1,25 @@
+import type { ChartDatasetState } from './types';
+export declare function unzipWorkbook(bytes: Uint8Array): Record<string, Uint8Array>;
+export interface WorkbookMap {
+    readonly sheets: Map<string, string>;
+    readonly sharedStrings: string | null;
+}
+type DatasetValues = Pick<ChartDatasetState, 'categories' | 'series'>;
+export declare function workbookMap(parts: Readonly<Record<string, Uint8Array>>): WorkbookMap;
+export declare function workbookCanSync(workbook: Uint8Array | undefined, state: DatasetValues, verifyCache?: boolean, companions?: readonly DatasetValues[] | false): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+interface WorkbookOccupancy {
+    readonly occupied: Map<string, Set<string>>;
+    readonly merged: Map<string, Set<string>>;
+    readonly unsafe: Map<string, Set<string>>;
+}
+export declare function occupiedCells(parts: Readonly<Record<string, Uint8Array>>, map: WorkbookMap): WorkbookOccupancy;
+export declare function patchChartWorkbook(sourceBytes: Uint8Array, sourceState: ChartDatasetState): {
+    readonly bytes: Uint8Array;
+    readonly state: ChartDatasetState;
+};
+export {};

package/dist/chart/xml-data.d.ts

@@ -0,0 +1,14 @@
+import type { XmlElement, XmlNode } from '@web-ppt/edit-core/xml';
+export declare const chartXml: {
+    child: (node: XmlElement | null, name: string) => XmlElement | null;
+    children: (node: XmlElement | null, name?: string) => XmlElement[];
+};
+export declare const worksheetXml: {
+    child: (node: XmlElement | null, name: string) => XmlElement | null;
+    children: (node: XmlElement | null, name?: string) => XmlElement[];
+};
+export declare const xmlAttribute: (node: XmlElement | null, name: string) => string | null;
+export declare const xmlContent: (node: XmlElement | null) => string;
+export declare function appendXml(parent: XmlElement, node: XmlNode, before?: XmlNode | null): void;
+export declare function makeDataElement(parent: XmlElement, name: string, attributes?: readonly (readonly [string, string])[]): XmlElement;
+export declare function setDataText(node: XmlElement, value: string): void;

package/dist/chart/xml-namespaces.d.ts

@@ -0,0 +1,16 @@
+export declare const CHART_NS = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+export declare const DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
+export declare const PRESENTATION_NS = "http://schemas.openxmlformats.org/presentationml/2006/main";
+export declare const OFFICE_REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+export declare const PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";
+export declare const SPREADSHEET_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+export declare const STRICT_CHART_NS = "http://purl.oclc.org/ooxml/drawingml/chart";
+export declare const STRICT_DRAWING_NS = "http://purl.oclc.org/ooxml/drawingml/main";
+export declare const STRICT_PRESENTATION_NS = "http://purl.oclc.org/ooxml/presentationml/main";
+export declare const STRICT_OFFICE_REL_NS = "http://purl.oclc.org/ooxml/officeDocument/relationships";
+export declare const STRICT_SPREADSHEET_NS = "http://purl.oclc.org/ooxml/spreadsheetml/main";
+export declare const isChartNamespace: (value: string | null) => boolean;
+export declare const isDrawingNamespace: (value: string | null) => boolean;
+export declare const isPresentationNamespace: (value: string | null) => boolean;
+export declare const isOfficeRelationshipNamespace: (value: string | null) => boolean;
+export declare const isSpreadsheetNamespace: (value: string | null) => boolean;

package/dist/chart-design/index.d.ts

@@ -0,0 +1,10 @@
+import type { Editor } from '../editor';
+import type { EditDoc, ElementId } from '../types';
+import type { ChartDesign } from './types';
+export { CHART_TYPES } from './types';
+export type { ChartDesign, ChartType } from './types';
+export declare function queryChartDesign(doc: EditDoc, id: ElementId): ChartDesign;
+export declare function createChartDesignEditor(editor: Pick<Editor, 'doc' | 'exec'>): {
+    query: (id: ElementId) => ChartDesign;
+    set(id: ElementId, design: ChartDesign | null): import("..").TransactionResult;
+};

package/dist/chart-design/types.d.ts

@@ -0,0 +1,11 @@
+export declare const CHART_TYPES: readonly ["bar", "line", "area", "pie", "doughnut", "radar", "scatter", "bubble"];
+export type ChartType = typeof CHART_TYPES[number];
+export interface ChartDesign {
+    type?: ChartType;
+    horizontal?: boolean;
+    grouping?: 'standard' | 'stacked' | 'percentStacked';
+    palette?: readonly string[];
+    legend?: 'none' | 'left' | 'right' | 'top' | 'bottom';
+    labels?: boolean;
+    title?: string;
+}

package/dist/chart-design/xml.d.ts

@@ -0,0 +1,2 @@
+import type { ChartDesign } from './types';
+export declare function applyChartDesign(xml: string | Uint8Array, design: ChartDesign): string;