@ccpc/core 0.1.0 → 0.1.2

package/package.json

@@ -1,30 +1,11 @@
 {
   "name": "@ccpc/core",
-  "version": "0.1.0",
-  "private": false,
+  "version": "0.1.2",
   "description": "Core data model layer for editor",
   "license": "MIT",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "dev": "tsc -p tsconfig.json --watch --preserveWatchOutput",
-    "build": "tsc -p tsconfig.json",
-    "lint": "eslint . --ext .ts",
-    "lint:fix": "eslint . --ext .ts --fix"
+  "main": "./index.cjs",
+  "peerDependencies": {
+    "@ccpc/math": "^0.1.4"
   }
 }

package/types/display/dirty_prop.d.ts

@@ -0,0 +1,3 @@
+import { IPrototype } from '../types/type_guard';
+import type { StateObject } from './state_object';
+export declare function dirtyProp<T extends StateObject>(equals?: (o: unknown, n: unknown) => boolean): (target: IPrototype<T>, fieldName: string) => void;

package/types/display/state_object.d.ts

@@ -0,0 +1,30 @@
+export declare abstract class StateObject {
+    /** 脏标识 */
+    private _dirty;
+    /** 注销状态 */
+    private _disposed;
+    /** 脏属性池 */
+    protected _dirtyPropsPool: Map<string, unknown>;
+    /**
+     * 脏处理
+     */
+    dirty(): void;
+    /**
+     * 清理脏
+     */
+    unDirty(): void;
+    /**
+     * 是否脏
+     * @returns boolean
+     */
+    isDirty(): boolean;
+    /**
+     * 注销
+     */
+    dispose(): void;
+    /**
+     * 是否注销
+     * @returns
+     */
+    isDisposed(): boolean;
+}

package/types/document/doc_saver.d.ts

@@ -0,0 +1,13 @@
+import { IDocFile, IDocument } from './i_document';
+export declare class DocSaver {
+    private _doc;
+    constructor(doc: IDocument);
+    dump(): IDocFile;
+    private _dumpDoc;
+    /**
+     * 同步加载
+     */
+    syncLoad(file: IDocFile): boolean;
+    private _clearDocument;
+    private _fillDocument;
+}

package/types/document/document.d.ts

@@ -0,0 +1,37 @@
+import type { IElement } from '../element/i_element';
+import type { IDocFile, IDocument } from './i_document';
+import { IDPool } from './id_pool';
+import { ElementId } from '../element/element_id';
+import { TransactionMgr } from '../transaction/transaction_mgr';
+import { IConstructor } from '../types/type_guard';
+import { EN_ModelViewChanged } from '../types/type_define';
+import { ModelView } from '../model_view/model_view';
+export declare class Document implements IDocument {
+    isMainDoc: boolean;
+    /**
+     * 文档唯一标识
+     */
+    private _id;
+    /**是否可以创建对象*/
+    static canCreate: boolean;
+    readonly idPool: IDPool;
+    readonly elementMgr: import("./element_mgr").ElementMgr;
+    readonly transactionMgr: TransactionMgr;
+    readonly requestMgr: import("..").RequestMgr;
+    readonly modelView: ModelView;
+    constructor();
+    get id(): string;
+    set id(val: string);
+    create<T extends IElement>(ctor: IConstructor<T>): T;
+    deleteElementsById(...eIds: Array<number | ElementId>): boolean;
+    getElementById<T extends IElement>(id: ElementId | number): T | undefined;
+    getElementByIdEnsure<T extends IElement>(eleId: ElementId | number): T;
+    getElementsByIds(eleIds: Array<ElementId | number>): IElement[];
+    filterElements(filter?: (ele: IElement) => boolean): IElement[];
+    checkIfCanModifyDoc(): void;
+    cacheForViewElementChanged(evtType: EN_ModelViewChanged, elements: Array<IElement>): void;
+    updateView(rebuild?: boolean): boolean;
+    dump(): IDocFile;
+    load(file: IDocFile): this;
+    destroy(): void;
+}

package/types/document/element_mgr.d.ts

@@ -0,0 +1,28 @@
+import type { IElement, IElementCtor } from '../element/i_element';
+export declare class ElementMgr {
+    private static _instance?;
+    /**
+     * 当前文档中的所有对象
+     */
+    private readonly _elements;
+    /**
+     * 对象类管理器
+     */
+    private readonly _eleClsMgr;
+    static instance(): ElementMgr;
+    /**
+     * 注册Element
+     */
+    registerElement(ctor: string, eleCtor: IElementCtor): void;
+    /**
+     * 根据序列化id获取Element构造函数
+     */
+    getElementClsByCtor(ctor: string): IElementCtor | undefined;
+    getElementById<T extends IElement>(id: number): T;
+    getAllElements(): IElement[];
+    getAllElementIds(): number[];
+    add(element: IElement, force?: boolean): boolean;
+    delete(id: number): boolean;
+    clear(): void;
+}
+export declare const elementMgr: ElementMgr;

package/types/document/i_document.d.ts

@@ -0,0 +1,60 @@
+import { ElementId } from '../element/element_id';
+import type { IElement } from '../element/i_element';
+import { ModelView } from '../model_view/model_view';
+import { RequestMgr } from '../request/request_mgr';
+import { TransactionMgr } from '../transaction/transaction_mgr';
+import { EN_ModelViewChanged } from '../types/type_define';
+import { IConstructor } from '../types/type_guard';
+import type { ElementMgr } from './element_mgr';
+import { IDPool } from './id_pool';
+export type IElementFile = {
+    ctor: string;
+    [key: string]: unknown;
+};
+/**
+ * 文档JSON类型
+ */
+export type IDocFile = {
+    id: string;
+    doc?: Array<IElementFile>;
+};
+export interface IDocument {
+    /**是否为主文档*/
+    isMainDoc: boolean;
+    /**文档唯一标识*/
+    id: string;
+    readonly idPool: IDPool;
+    /**对象管理器*/
+    readonly elementMgr: ElementMgr;
+    /**事务管理器*/
+    readonly transactionMgr: TransactionMgr;
+    readonly requestMgr: RequestMgr;
+    readonly modelView: ModelView;
+    create<T extends IElement>(ctor: IConstructor<T>): T;
+    deleteElementsById(...ids: Array<number | ElementId>): boolean;
+    getElementById<T extends IElement>(id: ElementId | number): T | undefined;
+    /**根据id获取对象*/
+    getElementByIdEnsure<T extends IElement>(eleId: ElementId | number): T;
+    getElementsByIds(eleIds: Array<ElementId | number>): IElement[];
+    /**
+     * 根据序列化id获取Element的类
+     */
+    /**
+     * 返回文档中满足filter条件的Element
+     * filter为空返回所有Element
+     */
+    filterElements(filter?: (ele: IElement) => boolean): IElement[];
+    /**
+     * 检测是否允许修改文档
+     * 包括增加、删除和修改
+     */
+    checkIfCanModifyDoc(): void;
+    /**
+     * 缓存模型层视图变化
+     */
+    cacheForViewElementChanged(evtType: EN_ModelViewChanged, elements: Array<IElement>): void;
+    updateView(rebuild?: boolean): boolean;
+    destroy(): void;
+    dump(): IDocFile;
+    load(file: IDocFile): this;
+}

package/{dist → types}/document/id_pool.d.ts

@@ -14,7 +14,9 @@ export declare class IDPool {
     genTmpId(): ElementId | undefined;
     genUnstableId(): ElementId | undefined;
     genStableId(): ElementId;
+    /**
+     * 重置稳定ID的起始计数
+     */
     clearStableId(startIdx: number): void;
     isStableId(id: number): boolean;
 }
-//# sourceMappingURL=id_pool.d.ts.map

package/types/element/db.d.ts

@@ -0,0 +1,49 @@
+import { IJSON } from '../types/type_define';
+import { IDB, IModifiedProps } from './i_element';
+export declare class DB implements IDB {
+    private _db;
+    private _cache;
+    get db(): IJSON;
+    get cache(): IJSON;
+    /**
+     * 获取修改的数据
+     */
+    getModified(): IModifiedProps[];
+    /**
+     * 数据入库
+     */
+    commit(): void;
+    /**
+     * 数据回滚
+     */
+    rollBack(): void;
+    /**
+     * 清空缓存
+     */
+    private _clearCache;
+    ownKeys(): string[];
+    dump(): IJSON;
+    load(json: IJSON): void;
+    private _dumpData;
+    private _dumpArr;
+    /**
+     * 加载数组
+     * @param arr JSON中的数组
+     * @param first 参考数组中的第一个值
+     * 数组中元素当前只支持dump、load对象和基础类型
+     */
+    private _loadArr;
+    private _dumpMap;
+    /**
+     * Map中的元素支持dump、load对象和基础元素类型
+     */
+    private _loadMap;
+    private _dumpSet;
+    /**
+     * 当前Set只支持里面所有元素为同一类型
+     */
+    private _loadSet;
+    private _dumpAProperty;
+    private _isDumpLoad;
+    private _isBasicType;
+}

package/types/element/element.d.ts

@@ -0,0 +1,55 @@
+import { ElementId } from './element_id';
+import { type IElement, type T_SerializedId } from './i_element';
+import type { IDocument } from '../document/i_document';
+import { GRep } from '../grep/grep';
+import { DB } from './db';
+export declare class Element extends DB implements IElement {
+    /**
+     * 保存到文档中的序列化Id
+     */
+    static serializedId: T_SerializedId;
+    id: ElementId;
+    name: string;
+    private _doc;
+    visible: boolean;
+    C_GRep: GRep;
+    constructor();
+    getDoc(): IDocument;
+    setDoc(doc: IDocument): void;
+    /**
+     * 空构造+初始化
+     */
+    init(..._params: unknown[]): this;
+    /**
+     * 获取序列化的id
+     */
+    getSerialId(): string;
+    /**
+     * 重置缓存的 GRep，强制后续重新生成图形表示。
+     */
+    markGRepDirty(): void;
+    /**
+     * 获取GRep显示对象
+     */
+    getGRep(): GRep;
+    getGRepWhenSelected(): GRep;
+    getGRepWhenActive(): GRep;
+    /**
+     * 设置GRep显示对象
+     */
+    setGRep(grep: GRep): boolean;
+    isElementVisible(): boolean;
+    /**
+     * 是否为临时对象
+     * 临时对象不受事务监管
+     */
+    isTemporary(): boolean;
+    dontSave(): boolean;
+    dontShowView(): boolean;
+    /**
+     * 属性变化是否应该缓存到视图
+     */
+    propShouldCacheToView(propName: string): boolean;
+    clone(): this;
+    onLoad(): void;
+}

package/{dist → types}/element/element_decorator.d.ts

@@ -1,3 +1,2 @@
 import { IElement, IElementCtor } from './i_element';
 export declare const RegisterElement: (ctorStr: string) => <T extends IElement>(Ctor: IElementCtor<T>) => void;
-//# sourceMappingURL=element_decorator.d.ts.map

package/{dist → types}/element/element_id.d.ts

@@ -1,4 +1,4 @@
-import type { IDBEleId } from '../types/dump_type';
+import { IDBEleId } from '../types/type_define';
 declare class ElementId {
     static get INVALID(): ElementId;
     protected _id: number;
@@ -11,4 +11,3 @@ declare class ElementId {
     load(json: IDBEleId): void;
 }
 export { ElementId };
-//# sourceMappingURL=element_id.d.ts.map

package/types/element/i_element.d.ts

@@ -0,0 +1,64 @@
+import { IDocument } from '../document/i_document';
+import { GRep } from '../grep/grep';
+import { IJSON } from '../types/type_define';
+import { ElementId } from './element_id';
+export type IModifiedProps = {
+    propertyName: string;
+    oldValue: unknown;
+    newValue: unknown;
+};
+export interface IDB {
+    readonly db: Record<string, unknown>;
+    readonly cache: Record<string, unknown>;
+    getModified(): IModifiedProps[];
+    commit(): void;
+    rollBack(): void;
+    dump(): IJSON;
+    load(val: IJSON): void;
+}
+export interface IElement extends IDB {
+    id: ElementId;
+    name: string;
+    getDoc(): IDocument;
+    setDoc(doc: IDocument): void;
+    init(...params: unknown[]): this;
+    getSerialId(): string;
+    getGRep(): GRep;
+    /**
+     * 获取选中GRep
+     */
+    getGRepWhenSelected(): GRep;
+    /**
+     * 获取高亮GRep
+     */
+    getGRepWhenActive(): GRep;
+    setGRep(grep: GRep): boolean;
+    isElementVisible(): boolean;
+    isTemporary(): boolean;
+    dontSave(): boolean;
+    dontShowView(): boolean;
+    propShouldCacheToView(propName: string): boolean;
+    clone(): this;
+    onLoad(): void;
+}
+export type T_SerializedId = {
+    /**类序列化的唯一标识*/
+    ctor: string;
+};
+export type IElementCtor<T extends IElement = IElement> = {
+    new (): T;
+    serializedId: T_SerializedId;
+};
+export declare const EN_VIEW_CACHE_PROPS: {
+    readonly C_GREP: "C_GRep";
+    readonly VISIBLE: "visible";
+};
+export type IDumpLoad = {
+    dump(): unknown;
+    load(val: unknown): void;
+};
+export declare const MathSymbol: unique symbol;
+export declare const DBGenerator: {
+    newGeoArray: <T>() => T[];
+    newGeoObject: <T>() => T;
+};

package/types/element/tmp_element/tmp_element.d.ts

@@ -0,0 +1,6 @@
+import { Element } from '../element';
+export declare class TmpElement extends Element {
+    init(): this;
+    dontSave(): boolean;
+    isTemporary(): boolean;
+}

package/types/element/tmp_element/tmp_element_painter.d.ts

@@ -0,0 +1,27 @@
+import { IDocument } from '../../document/i_document';
+import { GRep } from '../../grep/grep';
+/**
+ * 临时元素绘制器
+ */
+export declare class TmpElementPainter {
+    /**
+     * 临时元素id
+     */
+    private _tmpElementId;
+    private _tmpGRepRemoved;
+    private _doc;
+    constructor(doc: IDocument);
+    get tmpElement(): import("../i_element").IElement;
+    /**
+     * 绘制临时元素
+     */
+    drawTmpGRep(grep: GRep): void;
+    /**
+     * 清除临时元素
+     */
+    clearTmp(): void;
+    /**
+     * 销毁
+     */
+    destroy(): void;
+}

package/types/grep/display/display_object.d.ts

@@ -0,0 +1,37 @@
+import type { GRep } from '../grep';
+import { StateObject } from '../../display/state_object';
+export interface IDisplayRenderData {
+    gRep?: GRep;
+}
+export interface IMgrDisplayRenderData extends IDisplayRenderData {
+    id: number;
+}
+/**
+ * 最小单类显示对象。
+ * 当前只保留跑通 GRep 渲染链路需要的公共能力。
+ */
+export declare abstract class DisplayObject extends StateObject {
+    private static _dID;
+    /**
+     * 统一显示对象 id，后续可作为渲染层主键。
+     */
+    readonly id: number;
+    /**
+     * 在render层创建出group后，设置visible属性。
+     * display 直接改，modelview里 updateElementVisible。
+     * 控制整棵树显隐，grep中的visible控制图元是否参与渲染。
+     */
+    visible?: boolean;
+    constructor();
+    /**
+     * 统一判断当前对象是否应该显示。
+     */
+    testVisible(): boolean;
+    /**
+     * 给子类补充额外显示条件。
+     */
+    visibleCheck(): boolean;
+    onBeforeRender(rebuild?: boolean): IDisplayRenderData | null;
+    onRender(): IDisplayRenderData | null;
+    dispose(): void;
+}

package/types/grep/display/display_object_mgr.d.ts

@@ -0,0 +1,23 @@
+import type { IMgrDisplayRenderData } from './display_object';
+import { DisplayObject } from './display_object';
+export declare class DisplayObjectMgr {
+    /** 显示对象集合。 */
+    private _displayMap;
+    /** 本轮被移除的显示对象 id。 */
+    private _removedSet;
+    /** 单例实例。 */
+    private static _instance;
+    constructor();
+    addDisplay(display: DisplayObject): void;
+    getDisplay<T extends DisplayObject>(id: number): T | undefined;
+    removeDisplayById(id: number): boolean;
+    /**
+     * 渲染前准备
+     */
+    onBeforeRender(rebuild?: boolean): {
+        update: IMgrDisplayRenderData[];
+        remove: number[];
+    };
+    clearDisplay(): void;
+    static instance(): DisplayObjectMgr;
+}

package/types/grep/display/grep_display.d.ts

@@ -0,0 +1,16 @@
+import type { GRep } from '../grep';
+import type { IDisplayRenderData } from './display_object';
+import { DisplayObject } from './display_object';
+export declare class GrepDisplay extends DisplayObject {
+    /**
+     * 当前显示对象对应的 GRep。
+     */
+    gRep: GRep;
+    /**
+     * 关联的 elementId。
+     * 先保留，便于继续兼容当前 ModelView 链路。
+     */
+    eId: number;
+    getGRep(): GRep;
+    onRender(): IDisplayRenderData | null;
+}

package/types/grep/gcurve2d.d.ts

@@ -0,0 +1,15 @@
+import { Curve2, DiscreteParam, Plane } from '@ccpc/math';
+import type { types } from '@ccpc/math';
+import { GNode2d } from './gnode2d';
+import { RenderNode } from '../render/render_node';
+import { GNODE_TYPE } from './gnode_type';
+import { IStyle } from './i_style';
+export declare class GCurve2d extends GNode2d {
+    geo: Curve2;
+    constructor(plane: Plane, geo: Curve2);
+    setStyle(style: IStyle): this;
+    getType(): GNODE_TYPE;
+    protected _toRenderNodeWithoutMatrix(discreteParams?: DiscreteParam): RenderNode;
+    discrete(params?: DiscreteParam): types.IXYZ[];
+    clone(cloneGeo?: boolean): GCurve2d;
+}

package/types/grep/ggroup.d.ts

@@ -0,0 +1,29 @@
+import { DiscreteParam } from '@ccpc/math';
+import { RenderNode } from '../render/render_node';
+import { GNode } from './gnode';
+import { GNODE_TYPE } from './gnode_type';
+export declare class GGroup extends GNode {
+    /**
+     * 子节点
+     */
+    protected _children: Array<GNode>;
+    get children(): GNode[];
+    isEmpty(): boolean;
+    /**
+     * 添加子节点
+     */
+    addNode(node: GNode, index?: number): GNode;
+    /**
+     * 移除子节点
+     */
+    removeNode(node: GNode): boolean;
+    /**
+     * 批量添加子节点
+     */
+    addNodes(...nodes: Array<GNode | GNode[]>): void;
+    getTraverseChildren(): GNode[];
+    getType(): GNODE_TYPE;
+    protected _toRenderNodeWithoutMatrix(discreteParams?: DiscreteParam): RenderNode;
+    clone(cloneGeo?: boolean): GGroup;
+    protected _copyFrom(another: GGroup, cloneGeo?: boolean): this;
+}

package/types/grep/gnode.d.ts

@@ -0,0 +1,110 @@
+import { DiscreteParam, Matrix4 } from '@ccpc/math';
+import { RenderNode } from '../render/render_node';
+import { ElementId } from '../element/element_id';
+import { GNODE_TYPE } from './gnode_type';
+import { IStyle } from './i_style';
+/**
+ * 表示图形的基本单元, 包括几何数据和显示样式
+ */
+export declare abstract class GNode {
+    static gId: number;
+    /**
+     * dynamic global incremental
+     */
+    readonly globalID: number;
+    parent?: GNode;
+    /**
+     * 相对父节点局部矩阵
+     */
+    protected _localMatrix?: Matrix4;
+    /**
+     * 根节点累计到当前的世界矩阵
+     */
+    protected _globalMatrix?: Matrix4;
+    /**
+     * 对应的渲染节点
+     * 一旦创建出来, 会复用并在需要时同步矩阵
+     */
+    protected _renderNode?: RenderNode;
+    /**
+     * 渲染节点样式
+     */
+    protected _style: IStyle;
+    protected _canPick: boolean;
+    protected _canSnap: boolean;
+    get elementId(): ElementId;
+    get localMatrix(): Matrix4 | undefined;
+    set localMatrix(value: Matrix4);
+    get globalMatrix(): Matrix4 | undefined;
+    constructor();
+    /**
+     * set local style only (without mixing with parent style)
+     */
+    setStyle(style: IStyle): this;
+    /**
+     * get final style mixing child and parent
+     */
+    getStyle(): Partial<{
+        point: import("./i_style").IPointStyle;
+        line: import("./i_style").ILineStyle;
+        face: import("./i_style").IFaceStyle;
+        text: import("./i_style").ITextStyle;
+    }>;
+    get canPick(): boolean;
+    set canPick(canPick: boolean);
+    get canSnap(): boolean;
+    set canSnap(canSnap: boolean);
+    /**
+     * GNode->RenderNode入口
+     */
+    toRenderNode(discreteParams?: DiscreteParam): RenderNode;
+    /**
+     * 更新GNode对应的RenderNode
+     */
+    updateRenderNode(discreteParams?: DiscreteParam): void;
+    /**
+     * 设置局部坐标变换
+     */
+    setLocalMatrix(mat?: Matrix4): void;
+    /**
+     * 从当前节点的树根计算整棵子树的世界矩阵
+     */
+    updateGlobalMatrix(): void;
+    /**
+     * 递归计算当前节点及子节点的世界矩阵
+     */
+    protected _updateMatrix(parentGlobalMatrix?: Matrix4): void;
+    /**
+     * 查整根树的根节点
+     */
+    getRoot(): GNode;
+    traverse(callback: (gnode: GNode) => void): void;
+    /**
+     * 返回当前节点的可遍历子节点
+     */
+    getTraverseChildren(): Array<GNode>;
+    getType(): GNODE_TYPE;
+    /**
+     * 通过离散等方式生成对应的RenderNode
+     */
+    protected abstract _toRenderNodeWithoutMatrix(discreteParams?: DiscreteParam): RenderNode;
+    /**
+     * 清除_renderNode
+     * @param clearChildren 是否清除子节点renderNode
+     * @param clearParent 是否清除父节点renderNode
+     */
+    clearRenderNode(clearChildren?: boolean, clearParent?: boolean): void;
+    /**
+     * 从父节点移除
+     */
+    removeFromParent(): boolean;
+    /**
+     * 克隆
+     * @param cloneGeo 是否深拷贝底层几何对象
+     */
+    abstract clone(cloneGeo?: boolean): GNode;
+    /**
+     * 从其它实例复制状态
+     */
+    protected _copyFrom(another: GNode): this;
+}