chili3d 0.6.1

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

@@ -0,0 +1,26 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./asyncController";
+export * from "./binding";
+export * from "./collection";
+export * from "./converter";
+export * from "./deepObserver";
+export * from "./disposable";
+export * from "./dto";
+export * from "./equalityComparer";
+export * from "./gc";
+export * from "./history";
+export * from "./id";
+export * from "./lazy";
+export * from "./linkedList";
+export * from "./logger";
+export * from "./messageType";
+export * from "./objectStorage";
+export * from "./observer";
+export * from "./precision";
+export * from "./pubsub";
+export * from "./result";
+export * from "./storage";
+export * from "./transaction";
+export * from "./utils";

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

@@ -0,0 +1,18 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export class Lazy<T> {
+    #value?: T;
+    readonly #factory: () => T;
+
+    constructor(factory: () => T) {
+        this.#factory = factory;
+    }
+
+    get value(): T {
+        if (this.#value === undefined) {
+            this.#value = this.#factory();
+        }
+        return this.#value;
+    }
+}

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

@@ -0,0 +1,141 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+interface LinkedListNode<T> {
+    data: T;
+    next?: LinkedListNode<T>;
+    prev?: LinkedListNode<T>;
+}
+
+export class LinkedList<T> {
+    private _head: LinkedListNode<T> | undefined;
+    get head() {
+        return this._head?.data;
+    }
+
+    private _tail: LinkedListNode<T> | undefined;
+    get tail() {
+        return this._tail?.data;
+    }
+
+    private _size: number = 0;
+    get size() {
+        return this._size;
+    }
+
+    push(...items: T[]) {
+        for (const item of items) {
+            const node: LinkedListNode<T> = { data: item };
+            if (!this._head) {
+                this._head = this._tail = node;
+            } else {
+                node.prev = this._tail;
+                this._tail!.next = node;
+                this._tail = node;
+            }
+            this._size++;
+        }
+    }
+
+    insert(index: number, item: T) {
+        if (index < 0 || index >= this._size) return;
+        if (index === 0) {
+            const node: LinkedListNode<T> = { data: item, next: this._head };
+            if (this._head) this._head.prev = node;
+            this._head = node;
+            if (!this._tail) this._tail = node;
+            this._size++;
+            return;
+        }
+
+        const targetNode = this.nodeAt(index);
+        if (!targetNode) return;
+
+        const newNode: LinkedListNode<T> = {
+            data: item,
+            next: targetNode,
+            prev: targetNode.prev,
+        };
+
+        if (targetNode.prev) targetNode.prev.next = newNode;
+        targetNode.prev = newNode;
+        this._size++;
+    }
+
+    remove(item: T) {
+        let current = this._head;
+        while (current) {
+            if (current.data === item) {
+                this.removeNode(current);
+                return;
+            }
+            current = current.next;
+        }
+    }
+
+    removeAt(index: number) {
+        const node = this.nodeAt(index);
+        if (node) this.removeNode(node);
+    }
+
+    private removeNode(node: LinkedListNode<T>) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        } else {
+            this._head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        } else {
+            this._tail = node.prev;
+        }
+        this._size--;
+    }
+
+    private nodeAt(index: number): LinkedListNode<T> | undefined {
+        if (index < 0 || index >= this._size) return undefined;
+        if (index === 0) return this._head;
+        if (index === this._size - 1) return this._tail;
+
+        let current: LinkedListNode<T> | undefined;
+        if (index <= this._size / 2) {
+            current = this._head;
+            for (let i = 0; i < index; i++) {
+                current = current!.next;
+            }
+        } else {
+            current = this._tail;
+            for (let i = this._size - 1; i > index; i--) {
+                current = current!.prev;
+            }
+        }
+        return current;
+    }
+
+    clear() {
+        this._head = undefined;
+        this._tail = undefined;
+        this._size = 0;
+    }
+
+    reverse() {
+        let currentNode = this._head;
+        while (currentNode) {
+            const next = currentNode.next;
+            currentNode.next = currentNode.prev;
+            currentNode.prev = next;
+            currentNode = currentNode.prev;
+        }
+        const tail = this._tail;
+        this._tail = this._head;
+        this._head = tail;
+    }
+
+    *[Symbol.iterator](): IterableIterator<T> {
+        let current = this._head;
+        while (current) {
+            yield current.data;
+            current = current.next;
+        }
+    }
+}

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

@@ -0,0 +1,45 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export enum LoggerLevel {
+    Debug,
+    Info,
+    Warn,
+    Error,
+}
+
+export class Logger {
+    static level: LoggerLevel = LoggerLevel.Info;
+
+    static debug(message?: any, ...optionalParams: any[]) {
+        if (Logger.level <= LoggerLevel.Debug) {
+            console.debug(message, ...optionalParams);
+        }
+    }
+
+    static info(message?: any, ...optionalParams: any[]) {
+        if (Logger.level <= LoggerLevel.Info) {
+            console.log(message, ...optionalParams);
+        }
+    }
+
+    static warn(message?: any, ...optionalParams: any[]) {
+        if (Logger.level <= LoggerLevel.Warn) {
+            console.warn(message, ...optionalParams);
+        }
+    }
+
+    static error(message?: any, ...optionalParams: any[]) {
+        if (Logger.level <= LoggerLevel.Error) {
+            console.error(message, ...optionalParams);
+        }
+    }
+}
+
+// facilitate debugging
+if (!__IS_PRODUCTION__) {
+    Logger.debug = console.debug;
+    Logger.info = console.log;
+    Logger.warn = console.warn;
+    Logger.error = console.error;
+}

package/packages/chili-core/src/foundation/messageType.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 enum MessageType {
+    info,
+    warn,
+    error,
+}

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

@@ -0,0 +1,50 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export class ObjectStorage {
+    static readonly default = new ObjectStorage("chili3d", "app");
+
+    private readonly prefix: string;
+
+    constructor(organization: string, application: string) {
+        this.prefix = `${organization}.${application}.`;
+    }
+
+    setValue(key: string, value: object): void {
+        const storageKey = this.prefix + key;
+        try {
+            const stringValue = JSON.stringify(value);
+            localStorage.setItem(storageKey, stringValue);
+        } catch (error) {
+            console.error(`Failed to set setting ${key}:`, error);
+        }
+    }
+
+    value<T>(key: string, defaultValue?: T): T | undefined {
+        const storageKey = this.prefix + key;
+        const item = localStorage.getItem(storageKey);
+        if (!item) {
+            return defaultValue;
+        }
+
+        try {
+            return JSON.parse(item) as T;
+        } catch (error) {
+            console.error(`Failed to get setting ${key}:`, error);
+            return defaultValue;
+        }
+    }
+
+    remove(key: string): void {
+        const storageKey = this.prefix + key;
+        localStorage.removeItem(storageKey);
+    }
+
+    clear(): void {
+        Object.keys(localStorage).forEach((key) => {
+            if (key.startsWith(this.prefix)) {
+                localStorage.removeItem(key);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,147 @@
+// 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 { IDisposable } from "./disposable";
+import type { IEqualityComparer } from "./equalityComparer";
+import { PropertyHistoryRecord } from "./history";
+import { Logger } from "./logger";
+import { Transaction } from "./transaction";
+
+export type PropertyChangedHandler<T, K extends keyof T> = (property: K, source: T, oldValue: T[K]) => void;
+
+export interface IPropertyChanged extends IDisposable {
+    onPropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>): void;
+    removePropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>): void;
+    clearPropertyChanged(): void;
+}
+
+export function isPropertyChanged(obj: object): obj is IPropertyChanged {
+    return (
+        obj &&
+        typeof (obj as IPropertyChanged).onPropertyChanged === "function" &&
+        typeof (obj as IPropertyChanged).removePropertyChanged === "function"
+    );
+}
+
+export class Observable implements IPropertyChanged {
+    protected readonly propertyChangedHandlers = new Set<PropertyChangedHandler<any, any>>();
+    protected _isDisposed = false;
+
+    private getPrivateKey<K extends keyof this>(pubKey: K) {
+        return `_${String(pubKey)}`;
+    }
+
+    protected getPrivateValue<K extends keyof this>(pubKey: K, defaultValue?: this[K]): this[K] {
+        const privateKey = this.getPrivateKey(pubKey) as keyof this;
+        return privateKey in this
+            ? (this[privateKey] as this[K])
+            : this.initializeDefaultValue(pubKey, defaultValue);
+    }
+
+    private initializeDefaultValue<K extends keyof this>(pubKey: K, defaultValue?: this[K]): this[K] {
+        if (defaultValue === undefined) {
+            Logger.warn(
+                `${this.constructor.name}: The property "${String(pubKey)}" is not initialized, and no default value is provided`,
+            );
+            return undefined as this[K];
+        }
+
+        const privateKey = this.getPrivateKey(pubKey);
+        (this as any)[privateKey] = defaultValue;
+        return defaultValue;
+    }
+
+    setPrivateValue<K extends keyof this>(pubKey: K, newValue: this[K]): void {
+        (this as any)[this.getPrivateKey(pubKey)] = newValue;
+    }
+
+    /**
+     * Set the value of a private property, and if successful, execute emitPropertyChanged.
+     *
+     * Note: The private property name must be the public property name with the prefix _, i.e., age->_age(private property name).
+     */
+    protected setProperty<K extends keyof this>(
+        property: K,
+        newValue: this[K],
+        onPropertyChanged?: (property: K, oldValue: this[K]) => void,
+        equals?: IEqualityComparer<this[K]>,
+    ): boolean {
+        const oldValue = this[property];
+        if (this.isEuqals(oldValue, newValue, equals)) return false;
+
+        this.setPrivateValue(property, newValue);
+        onPropertyChanged?.(property, oldValue);
+        this.emitPropertyChanged(property, oldValue);
+        return true;
+    }
+
+    private isEuqals<K extends keyof this>(
+        oldValue: this[K],
+        newValue: this[K],
+        equals?: IEqualityComparer<this[K]>,
+    ): boolean {
+        return equals ? equals.equals(oldValue, newValue) : oldValue === newValue;
+    }
+
+    protected emitPropertyChanged<K extends keyof this>(property: K, oldValue: this[K]) {
+        Array.from(this.propertyChangedHandlers).forEach((cb) => cb(property, this, oldValue));
+    }
+
+    onPropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>) {
+        this.propertyChangedHandlers.add(handler);
+    }
+
+    removePropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>) {
+        this.propertyChangedHandlers.delete(handler);
+    }
+
+    clearPropertyChanged(): void {
+        this.propertyChangedHandlers.clear();
+    }
+
+    readonly dispose = () => {
+        if (this._isDisposed) return;
+        this._isDisposed = true;
+        this.disposeInternal();
+    };
+
+    protected disposeInternal() {
+        this.propertyChangedHandlers.clear();
+    }
+}
+
+export abstract class HistoryObservable extends Observable {
+    private _document: IDocument;
+
+    get document(): IDocument {
+        return this._document;
+    }
+
+    constructor(document: IDocument) {
+        super();
+        this._document = document;
+    }
+
+    protected override setProperty<K extends keyof this>(
+        property: K,
+        newValue: this[K],
+        onPropertyChanged?: (property: K, oldValue: this[K]) => void,
+        equals?: IEqualityComparer<this[K]>,
+    ): boolean {
+        return super.setProperty(
+            property,
+            newValue,
+            (property, oldValue) => {
+                onPropertyChanged?.(property, oldValue);
+                Transaction.add(this.document, new PropertyHistoryRecord(this, property, oldValue, newValue));
+            },
+            equals,
+        );
+    }
+
+    override disposeInternal() {
+        super.disposeInternal();
+        this._document = null as any;
+    }
+}

package/packages/chili-core/src/foundation/precision.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 namespace Precision {
+    export const Distance = 1e-7;
+    export const Angle = 1e-3;
+    export const Float = 1e-7;
+}

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

@@ -0,0 +1,74 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { CommandKeys, ICommand } from "../command";
+import type { IDocument } from "../document";
+import type { I18nKeys } from "../i18n";
+import type { Material } from "../material";
+import type { INode } from "../model";
+import type { DialogResult } from "../ui";
+import type { CursorType, IView } from "../visual";
+import type { AsyncController } from "./asyncController";
+import type { IDisposable } from "./disposable";
+import type { MessageType } from "./messageType";
+import type { Result } from "./result";
+
+export interface PubSubEventMap {
+    activeViewChanged: (view: IView | undefined) => void;
+    clearFloatTip: () => void;
+    clearInput: () => void;
+    clearSelectionControl: () => void;
+    clearStatusBarTip: () => void;
+    closeCommandContext: () => void;
+    displayError: (message: string) => void;
+    displayHome: (show: boolean) => void;
+    documentClosed: (document: IDocument) => void;
+    editMaterial: (document: IDocument, material: Material, callback: (material: Material) => void) => void;
+    executeCommand: (commandName: CommandKeys) => void;
+    modelUpdate: (model: INode) => void;
+    openCommandContext: (command: ICommand) => void;
+    parentVisibleChanged: (model: INode) => void;
+    selectionChanged: (document: IDocument, selected: INode[], unselected: INode[]) => void;
+    showDialog: (title: I18nKeys, content: HTMLElement, callback?: (result: DialogResult) => void) => void;
+    showFloatTip: (dom: HTMLElement | { level: MessageType; msg: string }) => void;
+    showInput: (text: string, handler: (text: string) => Result<string, I18nKeys>) => void;
+    showPermanent: (action: () => Promise<void>, message: I18nKeys, ...args: any[]) => void;
+    showProperties(document: IDocument, nodes: INode[]): void;
+    showSelectionControl: (controller: AsyncController) => void;
+    showToast: (message: I18nKeys, ...args: any[]) => void;
+    statusBarTip: (tip: I18nKeys) => void;
+    viewClosed: (view: IView) => void;
+    viewCursor: (cursor: CursorType) => void;
+    visibleChanged: (model: INode) => void;
+}
+
+type EventCallback = (...args: any[]) => void;
+type EventMap = Map<keyof PubSubEventMap, Set<EventCallback>>;
+
+export class PubSub implements IDisposable {
+    static readonly default = new PubSub();
+    private readonly events: EventMap = new Map();
+
+    dispose(): void {
+        this.events.forEach((callbacks) => callbacks.clear());
+        this.events.clear();
+    }
+
+    sub<K extends keyof PubSubEventMap>(event: K, callback: PubSubEventMap[K]): void {
+        const callbacks = this.events.get(event) ?? new Set<EventCallback>();
+        callbacks.add(callback);
+        this.events.set(event, callbacks);
+    }
+
+    pub<K extends keyof PubSubEventMap>(event: K, ...args: Parameters<PubSubEventMap[K]>): void {
+        this.events.get(event)?.forEach((callback) => callback(...args));
+    }
+
+    remove<K extends keyof PubSubEventMap>(event: K, callback: PubSubEventMap[K]): void {
+        this.events.get(event)?.delete(callback);
+    }
+
+    removeAll<K extends keyof PubSubEventMap>(event: K): void {
+        this.events.get(event)?.clear();
+    }
+}

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

@@ -0,0 +1,69 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Serializer } from "../serialize";
+import type { IEqualityComparer } from "./equalityComparer";
+import { Logger } from "./logger";
+
+@Serializer.register(["isOk", "value", "error"])
+export class Result<T, E = string> {
+    readonly #isOk: boolean;
+    readonly #value: T | undefined;
+    readonly #error: E | undefined;
+
+    @Serializer.serialze()
+    get isOk(): boolean {
+        return this.#isOk;
+    }
+
+    @Serializer.serialze()
+    get value(): T {
+        if (!this.#isOk) Logger.warn("Result is error");
+        return this.#value!;
+    }
+
+    @Serializer.serialze()
+    get error(): E {
+        if (this.#isOk) Logger.warn("Result is ok");
+        return this.#error!;
+    }
+
+    constructor(isOk: boolean, value: T | undefined, error: E | undefined) {
+        this.#isOk = isOk;
+        this.#value = value;
+        this.#error = error;
+    }
+
+    parse<U>(): Result<U, E> {
+        return Result.err(this.#error as E);
+    }
+
+    isOkAnd(predict: (value: T) => boolean): boolean {
+        return this.#isOk && predict(this.#value!);
+    }
+
+    isErrorOr(predict: (value: T) => boolean): boolean {
+        return !this.#isOk || predict(this.#value!);
+    }
+
+    unchecked(): T | undefined {
+        return this.#value;
+    }
+
+    static ok<T>(value: T): Result<T, never> {
+        return new Result(true, value, undefined) as any;
+    }
+
+    static err<E>(error: E): Result<any, E> {
+        return new Result(false, undefined, error) as any;
+    }
+}
+
+export class ResultEqualityComparer<T> implements IEqualityComparer<Result<T>> {
+    constructor(readonly equal?: (left: T, right: T) => boolean) {}
+
+    equals(left: Result<T>, right: Result<T>): boolean {
+        if (!left.isOk || !right.isOk) return false;
+        return this.equal ? this.equal(left.value, right.value) : left.value === right.value;
+    }
+}

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

@@ -0,0 +1,10 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export interface IStorage {
+    readonly version: number;
+    get(database: string, table: string, id: string): Promise<any>;
+    put(database: string, table: string, id: string, value: any): Promise<boolean>;
+    delete(database: string, table: string, id: string): Promise<boolean>;
+    page(database: string, table: string, page: number): Promise<any[]>;
+}

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

@@ -0,0 +1,77 @@
+// 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 { ArrayRecord, type IHistoryRecord } from "./history";
+import { Logger } from "./logger";
+
+export class Transaction {
+    private static readonly _transactionMap: WeakMap<IDocument, ArrayRecord> = new WeakMap();
+
+    constructor(
+        readonly document: IDocument,
+        readonly name: string,
+    ) {}
+
+    static add(document: IDocument, record: IHistoryRecord) {
+        if (document.history.disabled) return;
+        const arrayRecord = Transaction._transactionMap.get(document);
+        if (arrayRecord !== undefined) {
+            arrayRecord.records.push(record);
+        } else {
+            Transaction.addToHistory(document, record);
+        }
+    }
+
+    static addToHistory(document: IDocument, record: IHistoryRecord) {
+        document.history.add(record);
+        Logger.info(`history added ${record.name}`);
+    }
+
+    static execute(document: IDocument, name: string, action: () => void) {
+        const trans = new Transaction(document, name);
+        trans.start();
+        try {
+            action();
+            trans.commit();
+        } catch (e) {
+            trans.rollback();
+            throw e;
+        }
+    }
+
+    static async executeAsync(document: IDocument, name: string, action: () => Promise<void>) {
+        const trans = new Transaction(document, name);
+        trans.start();
+
+        await Promise.try(async () => {
+            await action();
+            trans.commit();
+        }).catch((e) => {
+            trans.rollback();
+            throw e;
+        });
+    }
+
+    start(name?: string) {
+        const transactionName = name ?? this.name;
+        if (Transaction._transactionMap.has(this.document)) {
+            throw new Error(`The document has started a transaction ${this.name}`);
+        }
+        Transaction._transactionMap.set(this.document, new ArrayRecord(transactionName));
+    }
+
+    commit() {
+        const arrayRecord = Transaction._transactionMap.get(this.document);
+        if (!arrayRecord) {
+            throw new Error("Transaction has not started");
+        }
+        if (arrayRecord.records.length > 0) Transaction.addToHistory(this.document, arrayRecord);
+        Transaction._transactionMap.delete(this.document);
+    }
+
+    rollback() {
+        Transaction._transactionMap.get(this.document)?.undo();
+        Transaction._transactionMap.delete(this.document);
+    }
+}