chili3d 0.6.1

package/packages/chili-core/src/command/command.ts

@@ -0,0 +1,154 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IApplication } from "../application";
+import { type AsyncController, type IDisposable, Observable, PubSub } from "../foundation";
+import { Property } from "../property";
+
+export interface ICommand {
+    execute(application: IApplication): Promise<void>;
+}
+
+export interface ICanclableCommand extends ICommand, IDisposable {
+    cancel(): Promise<void>;
+}
+
+export namespace ICommand {
+    export function isCancelableCommand(command: ICommand): command is ICanclableCommand {
+        return "cancel" in command;
+    }
+}
+
+export abstract class CancelableCommand extends Observable implements ICanclableCommand {
+    private static readonly _propertiesCache: Map<string, any> = new Map(); // 所有命令共享
+    protected readonly disposeStack: Set<IDisposable> = new Set();
+
+    private _isCompleted: boolean = false;
+    get isCompleted() {
+        return this._isCompleted;
+    }
+
+    private _isCanceled: boolean = false;
+    get isCanceled() {
+        return this._isCanceled;
+    }
+
+    private _application: IApplication | undefined;
+    get application() {
+        if (!this._application) {
+            throw new Error("application is not set");
+        }
+        return this._application;
+    }
+
+    get document() {
+        return this.application.activeView?.document!;
+    }
+
+    #controller?: AsyncController;
+    protected get controller() {
+        return this.#controller;
+    }
+    protected set controller(value: AsyncController | undefined) {
+        if (this.#controller === value) return;
+        this.#controller?.dispose();
+        this.#controller = value;
+    }
+
+    @Property.define("common.cancel")
+    async cancel() {
+        this._isCanceled = true;
+
+        this.controller?.cancel();
+        while (!this._isCompleted) {
+            await new Promise((r) => setTimeout(r, 30));
+        }
+    }
+
+    @Property.define("option.command.repeat")
+    get repeatOperation() {
+        return this.getPrivateValue("repeatOperation", false);
+    }
+
+    set repeatOperation(value: boolean) {
+        this.setProperty("repeatOperation", value);
+    }
+
+    protected _isRestarting: boolean = false;
+    protected async restart() {
+        this._isRestarting = true;
+        await this.cancel();
+    }
+
+    protected onRestarting() {}
+
+    async execute(application: IApplication): Promise<void> {
+        if (!application.activeView?.document) return;
+        this._application = application;
+
+        await Promise.try(async () => {
+            this.beforeExecute();
+
+            await this.executeAsync();
+
+            while (this._isRestarting || (!this.checkCanceled() && this.repeatOperation)) {
+                this._isRestarting = false;
+
+                this.onRestarting();
+                await this.executeAsync();
+            }
+        }).finally(() => {
+            this.afterExecute();
+        });
+    }
+
+    protected checkCanceled() {
+        if (this.isCanceled) {
+            return true;
+        }
+
+        if (this.controller?.result?.status === "cancel") {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected abstract executeAsync(): Promise<void>;
+
+    protected beforeExecute() {
+        this.readProperties();
+        PubSub.default.pub("openCommandContext", this);
+    }
+
+    protected afterExecute() {
+        this.saveProperties();
+        PubSub.default.pub("closeCommandContext");
+        this.controller?.dispose();
+        this.disposeStack.forEach((x) => x.dispose());
+        this.disposeStack.clear();
+        this._isCompleted = true;
+    }
+
+    private readProperties() {
+        Property.getProperties(this).forEach((x) => {
+            const key = this.cacheKeyOfProperty(x);
+            if (CancelableCommand._propertiesCache.has(key)) {
+                this.setPrivateValue(key as keyof this, CancelableCommand._propertiesCache.get(key));
+            }
+        });
+    }
+
+    private saveProperties() {
+        Property.getProperties(this).forEach((x) => {
+            const key = this.cacheKeyOfProperty(x);
+            const prop = (this as any)[key];
+            if (typeof prop === "function") return;
+            CancelableCommand._propertiesCache.set(key, prop);
+        });
+    }
+
+    private cacheKeyOfProperty(property: Property) {
+        return property.name;
+    }
+}

package/packages/chili-core/src/command/commandKeys.ts

@@ -0,0 +1,8 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { I18nKeys } from "../i18n";
+
+export type CommandKeys = {
+    [P in I18nKeys]: P extends `command.${infer K}` ? K : never;
+}[I18nKeys];

package/packages/chili-core/src/command/decarator.ts

@@ -0,0 +1,43 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { Binding } from "../foundation";
+import type { ICommand } from "./command";
+import type { CommandKeys } from "./commandKeys";
+
+const commandRegistry = new Map<string, CommandConstructor>();
+
+export type CommandConstructor = new (...args: any[]) => ICommand;
+
+export interface CommandData {
+    key: CommandKeys;
+    icon: string;
+    toggle?: Binding;
+    helpText?: string;
+    helpUrl?: string;
+    isApplicationCommand?: boolean;
+}
+
+export function command<T extends CommandConstructor>(metadata: CommandData) {
+    return (ctor: T) => {
+        commandRegistry.set(metadata.key, ctor);
+        ctor.prototype.data = metadata;
+    };
+}
+
+export namespace Command {
+    export function getData(target: string | ICommand | CommandConstructor): CommandData | undefined {
+        if (typeof target === "string") {
+            const ctor = commandRegistry.get(target);
+            return ctor?.prototype.data;
+        }
+
+        const prototype = typeof target === "function" ? target.prototype : Object.getPrototypeOf(target);
+
+        return prototype.data;
+    }
+
+    export function get(name: CommandKeys): CommandConstructor | undefined {
+        return commandRegistry.get(name);
+    }
+}

package/packages/chili-core/src/command/index.ts

@@ -0,0 +1,6 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./command";
+export * from "./commandKeys";
+export * from "./decarator";

package/packages/chili-core/src/config.ts

@@ -0,0 +1,145 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { ObjectStorage, Observable } from "./foundation";
+import { I18n } from "./i18n";
+import { type SerializedProperties, Serializer } from "./serialize";
+import { ObjectSnapType } from "./snapType";
+
+export class VisualItemConfig extends Observable {
+    defaultFaceColor = 0xdedede;
+    highlightEdgeColor = 0x33ff33;
+    highlightFaceColor = 0x99ff00;
+    selectedEdgeColor = 0x33ff33;
+    selectedFaceColor = 0x33ff33;
+    editVertexSize = 7;
+    editVertexColor = 0x33ff33;
+    hintVertexSize = 5;
+    hintVertexColor = 0x33ff33;
+    trackingVertexSize = 7;
+    trackingVertexColor = 0x33ff33;
+    temporaryVertexSize = 5;
+    temporaryVertexColor = 0x33ff33;
+    temporaryEdgeColor = 0x33ff33;
+
+    get defaultEdgeColor() {
+        return this.getPrivateValue("defaultEdgeColor", 0x333333);
+    }
+    set defaultEdgeColor(value: number) {
+        this.setProperty("defaultEdgeColor", value);
+    }
+
+    applyTheme(theme: "light" | "dark") {
+        this.defaultEdgeColor = theme === "light" ? 0x333333 : 0xeeeeee;
+    }
+}
+
+export const VisualConfig = new VisualItemConfig();
+
+export class Config extends Observable {
+    static readonly #instance = new Config();
+
+    static get instance() {
+        return Config.#instance;
+    }
+
+    readonly SnapDistance: number = 5;
+
+    get snapType() {
+        return this.getPrivateValue(
+            "snapType",
+            ObjectSnapType.midPoint |
+                ObjectSnapType.endPoint |
+                ObjectSnapType.center |
+                ObjectSnapType.perpendicular |
+                ObjectSnapType.intersection |
+                ObjectSnapType.nearest,
+        );
+    }
+    set snapType(snapType: ObjectSnapType) {
+        this.setProperty("snapType", snapType);
+    }
+
+    get enableSnapTracking() {
+        return this.getPrivateValue("enableSnapTracking", true);
+    }
+    set enableSnapTracking(value: boolean) {
+        this.setProperty("enableSnapTracking", value);
+    }
+
+    get enableSnap() {
+        return this.getPrivateValue("enableSnap", true);
+    }
+    set enableSnap(value: boolean) {
+        this.setProperty("enableSnap", value);
+    }
+
+    get dynamicWorkplane() {
+        return this.getPrivateValue("dynamicWorkplane", true);
+    }
+    set dynamicWorkplane(value: boolean) {
+        this.setProperty("dynamicWorkplane", value);
+    }
+
+    @Serializer.serialze()
+    get language() {
+        return this.getPrivateValue("language", I18n.defaultLanguage());
+    }
+    set language(value: string) {
+        this.setProperty("language", value);
+    }
+
+    @Serializer.serialze()
+    get navigation3DIndex() {
+        return this.getPrivateValue("navigation3DIndex", 0);
+    }
+    set navigation3DIndex(value: number) {
+        this.setProperty("navigation3DIndex", value);
+    }
+
+    @Serializer.serialze()
+    get themeMode() {
+        return this.getPrivateValue("themeMode", "system");
+    }
+    set themeMode(value: "light" | "dark" | "system") {
+        this.setProperty("themeMode", value, () => {
+            if (value === "system") {
+                VisualConfig.applyTheme(
+                    window.matchMedia?.("(prefers-color-scheme: dark)").matches ? "dark" : "light",
+                );
+            } else {
+                VisualConfig.applyTheme(value);
+            }
+        });
+    }
+
+    #storageKey: string = "config";
+    get storageKey() {
+        return this.#storageKey;
+    }
+    private set storageKey(value: string) {
+        this.#storageKey = value;
+    }
+
+    private constructor() {
+        super();
+    }
+
+    init(storageKey: string) {
+        this.#storageKey = storageKey;
+        this.readFromStorage();
+    }
+
+    readFromStorage() {
+        const data = ObjectStorage.default.value<SerializedProperties<Config>>(this.storageKey);
+        for (const key in data) {
+            const thisKey = key as keyof Config;
+            this.setPrivateValue(thisKey, (data as any)[key]);
+        }
+    }
+
+    saveToStorage() {
+        const json = Serializer.serializeProperties(this);
+        ObjectStorage.default.setValue(this.storageKey, json);
+    }
+}

package/packages/chili-core/src/constants.ts

@@ -0,0 +1,8 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export class Constants {
+    static readonly DBName = "chili3d-db";
+    static readonly DocumentTable = "documents";
+    static readonly RecentTable = "recents";
+}

package/packages/chili-core/src/dataExchange.ts

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IDocument } from "./document";
+import type { VisualNode } from "./model";
+
+export interface IDataExchange {
+    importFormats(): string[];
+    exportFormats(): string[];
+    import(document: IDocument, files: FileList | File[]): Promise<void>;
+    export(type: string, nodes: VisualNode[]): Promise<BlobPart[] | undefined>;
+}

package/packages/chili-core/src/document.ts

@@ -0,0 +1,25 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IApplication } from "./application";
+import type { History, IDisposable, IPropertyChanged, ObservableCollection } from "./foundation";
+import type { ModelManager } from "./modelManager";
+import type { ISelection } from "./selection";
+import type { ISerialize, Serialized } from "./serialize";
+import type { Act, IVisual } from "./visual";
+
+export const DOCUMENT_FILE_EXTENSION = ".cd";
+
+export interface IDocument extends IPropertyChanged, IDisposable, ISerialize {
+    readonly selection: ISelection;
+    readonly id: string;
+    readonly history: History;
+    readonly visual: IVisual;
+    readonly application: IApplication;
+    readonly modelManager: ModelManager;
+    name: string;
+    acts: ObservableCollection<Act>;
+    save(): Promise<void>;
+    close(): Promise<void>;
+    serialize(): Serialized;
+}

package/packages/chili-core/src/editor.ts

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IView } from "./visual";
+
+export interface IEditor {
+    active(): boolean;
+    deactive(): boolean;
+    onPointerMove(view: IView, e: PointerEvent): void;
+    onPointerDown(view: IView, e: PointerEvent): void;
+    onPointerUp(view: IView, e: PointerEvent): void;
+}

package/packages/chili-core/src/foundation/asyncController.ts

@@ -0,0 +1,55 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IDisposable } from "./disposable";
+
+export interface AsyncResult {
+    status: "success" | "fail" | "cancel";
+    message?: string;
+}
+
+export class AsyncController implements IDisposable {
+    private readonly _failListeners = new Set<(state: AsyncResult) => void>();
+    private readonly _successListeners = new Set<(state: AsyncResult) => void>();
+    private _result: AsyncResult | undefined;
+
+    get result() {
+        return this._result;
+    }
+
+    readonly fail = (message?: string) => {
+        this.notifyListeners(this._failListeners, "fail", message);
+    };
+
+    readonly cancel = (message?: string) => {
+        this.notifyListeners(this._failListeners, "cancel", message);
+    };
+
+    readonly success = (message?: string) => {
+        this.notifyListeners(this._successListeners, "success", message);
+    };
+
+    private notifyListeners(
+        listeners: Set<(result: AsyncResult) => void>,
+        status: AsyncResult["status"],
+        message?: string,
+    ) {
+        if (this._result === undefined) {
+            this._result = { status, message };
+            listeners.forEach((listener) => listener(this._result!));
+        }
+    }
+
+    onCancelled(listener: (result: AsyncResult) => void): void {
+        this._failListeners.add(listener);
+    }
+
+    onCompleted(listener: (result: AsyncResult) => void): void {
+        this._successListeners.add(listener);
+    }
+
+    dispose() {
+        this._failListeners.clear();
+        this._successListeners.clear();
+    }
+}

package/packages/chili-core/src/foundation/binding.ts

@@ -0,0 +1,132 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IConverter } from "./converter";
+import type { IPropertyChanged } from "./observer";
+
+const registry = new FinalizationRegistry((binding: PathBinding<IPropertyChanged>) => {
+    binding.removeBinding();
+});
+
+/**
+ * Bind the property chain as a path, separated by dots
+ *
+ * @example
+ * ```ts
+ * const binding = new PathBinding(source, "a.b.c");
+ * binding.setBinding(element, "property");
+ * ```
+ */
+export class PathBinding<T extends IPropertyChanged = IPropertyChanged> {
+    private _target?: { element: WeakRef<object>; property: PropertyKey };
+    private _oldPathObjects?: { source: IPropertyChanged; property: string }[];
+    private _actualSource?: { source: IPropertyChanged; property: string };
+
+    constructor(
+        readonly source: T,
+        readonly path: string,
+        public converter?: IConverter,
+    ) {}
+
+    setBinding<U extends object>(element: U, property: keyof U) {
+        if (this._target) throw new Error("Binding already set");
+        this._target = { element: new WeakRef(element), property };
+        registry.register(element, this);
+        this.addPropertyChangedHandler();
+    }
+
+    removeBinding() {
+        const element = this._target?.element.deref();
+        if (element) registry.unregister(element);
+        this._target = undefined;
+        this.removePropertyChangedHandler();
+    }
+
+    private readonly handleAllPathPropertyChanged = (property: string, source: any) => {
+        if (this.shouldUpdateHandler(property, source)) {
+            this.removePropertyChangedHandler();
+            this.addPropertyChangedHandler();
+        }
+    };
+
+    private readonly handlePropertyChanged = (property: string, source: any) => {
+        if (this.path.endsWith(property) && this._target) {
+            this.setValue(source, property);
+        }
+    };
+
+    private shouldUpdateHandler(property: string, source: any) {
+        if (this._oldPathObjects === undefined) {
+            return true;
+        }
+
+        if (
+            this._oldPathObjects.some((element) => element.property === property && element.source === source)
+        ) {
+            return true;
+        }
+
+        if (!this._actualSource) {
+            return this.path.includes(property);
+        }
+
+        return false;
+    }
+
+    private addPropertyChangedHandler() {
+        const props = this.path.split(".");
+        let source: any = this.source;
+        this._oldPathObjects = [];
+        for (let i = 0; i < props.length; i++) {
+            if (!source || !(props[i] in source)) break;
+
+            const sourceProperty = { source, property: props[i] };
+            if (i === props.length - 1) {
+                this.setValue(source, props[i]);
+                this._actualSource = sourceProperty;
+                source.onPropertyChanged(this.handlePropertyChanged);
+                break;
+            }
+
+            source.onPropertyChanged(this.handleAllPathPropertyChanged);
+            this._oldPathObjects.push(sourceProperty);
+            source = source[props[i]];
+        }
+    }
+
+    private removePropertyChangedHandler() {
+        if (!this._oldPathObjects) return;
+        this._oldPathObjects.forEach((element) =>
+            element.source.removePropertyChanged(this.handleAllPathPropertyChanged),
+        );
+        this._actualSource?.source.removePropertyChanged(this.handlePropertyChanged);
+        this._actualSource = undefined;
+        this._oldPathObjects = undefined;
+    }
+
+    private setValue(source: any, property: string) {
+        if (!this._target) return;
+        const element = this._target.element.deref();
+        if (!element) return;
+
+        const value = source[property];
+        if (this.converter) {
+            const converted = this.converter.convert(value);
+            if (converted.isOk) (element as any)[this._target.property] = converted.value;
+        } else {
+            (element as any)[this._target.property] = value;
+        }
+    }
+
+    getPropertyValue() {
+        return this._actualSource
+            ? (this._actualSource.source as any)[this._actualSource.property]
+            : undefined;
+    }
+}
+
+export class Binding<T extends IPropertyChanged = IPropertyChanged> extends PathBinding<T> {
+    constructor(source: T, path: keyof T, converter?: IConverter) {
+        super(source, path.toString(), converter);
+    }
+}