chili3d 0.6.1

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

@@ -0,0 +1,208 @@
+// 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 enum CollectionAction {
+    add,
+    remove,
+    move,
+    replace,
+}
+
+export type CollectionChangedArgs =
+    | {
+          action: CollectionAction.add;
+          items: any[];
+      }
+    | {
+          action: CollectionAction.remove;
+          items: any[];
+      }
+    | {
+          action: CollectionAction.move;
+          from: number;
+          to: number;
+      }
+    | {
+          action: CollectionAction.replace;
+          index: number;
+          item: any;
+          items: any[];
+      };
+
+export interface ICollectionChanged {
+    onCollectionChanged(callback: (args: CollectionChangedArgs) => void): void;
+    removeCollectionChanged(callback: (args: CollectionChangedArgs) => void): void;
+}
+
+export class ObservableCollection<T> implements ICollectionChanged, IDisposable {
+    private readonly _callbacks = new Set<(args: CollectionChangedArgs) => void>();
+    private _items: T[];
+
+    constructor(...items: T[]) {
+        this._items = [...items];
+    }
+
+    push(...items: T[]) {
+        if (items.length === 0) return;
+        this._items.push(...items);
+        this.notifyChange({
+            action: CollectionAction.add,
+            items,
+        });
+    }
+
+    remove(...items: T[]) {
+        if (items.length === 0) return;
+        const itemSet = new Set(items);
+        this._items = this._items.filter((item) => !itemSet.has(item));
+        this.notifyChange({
+            action: CollectionAction.remove,
+            items,
+        });
+    }
+
+    move(from: number, to: number) {
+        if (!this.isValidMove(from, to)) return;
+
+        const items = this._items.splice(from, 1);
+        this._items.splice(from < to ? to - 1 : to, 0, ...items);
+        this.notifyChange({
+            action: CollectionAction.move,
+            from,
+            to,
+        });
+    }
+
+    private isValidMove(from: number, to: number): boolean {
+        return from !== to && from >= 0 && from < this._items.length && to >= 0 && to < this._items.length;
+    }
+
+    clear() {
+        if (this._items.length === 0) return;
+        const items = [...this._items];
+        this._items = [];
+        this.notifyChange({
+            action: CollectionAction.remove,
+            items,
+        });
+    }
+
+    get length() {
+        return this._items.length;
+    }
+
+    replace(index: number, ...items: T[]) {
+        if (!this.isValidIndex(index)) return;
+
+        const item = this._items[index];
+        this._items.splice(index, 1, ...items);
+        this.notifyChange({
+            action: CollectionAction.replace,
+            index,
+            item,
+            items,
+        });
+    }
+
+    private isValidIndex(index: number): boolean {
+        return index >= 0 && index < this._items.length;
+    }
+
+    private notifyChange(args: CollectionChangedArgs) {
+        this._callbacks.forEach((callback) => callback(args));
+    }
+
+    forEach(callback: (item: T, index: number) => void) {
+        this.items.forEach(callback);
+    }
+
+    map(callback: (item: T, index: number) => any) {
+        return this.items.map(callback);
+    }
+
+    get items() {
+        return [...this._items];
+    }
+
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
+
+    item(index: number) {
+        return this._items[index];
+    }
+
+    at(index: number) {
+        return this._items.at(index);
+    }
+
+    filter(predicate: (value: T, index: number, array: T[]) => boolean) {
+        return this._items.filter(predicate);
+    }
+
+    find(predicate: (value: T, index: number, array: T[]) => boolean) {
+        return this._items.find(predicate);
+    }
+
+    indexOf(item: T, fromIndex?: number) {
+        return this._items.indexOf(item, fromIndex);
+    }
+
+    contains(item: T) {
+        return this._items.indexOf(item) !== -1;
+    }
+
+    get count() {
+        return this._items.length;
+    }
+
+    onCollectionChanged(callback: (args: CollectionChangedArgs) => void): void {
+        this._callbacks.add(callback);
+    }
+
+    removeCollectionChanged(callback: (args: CollectionChangedArgs) => void): void {
+        this._callbacks.delete(callback);
+    }
+
+    dispose() {
+        this._callbacks.clear();
+        this._items.length = 0;
+    }
+}
+
+export enum SelectMode {
+    check,
+    radio,
+    combo,
+}
+
+export class SelectableItems<T> {
+    readonly items: ReadonlyArray<T>;
+    selectedItems: Set<T>;
+
+    get selectedIndexes(): number[] {
+        const indexes: number[] = [];
+        this.selectedItems.forEach((x) => {
+            const index = this.items.indexOf(x);
+            if (index > -1) {
+                indexes.push(index);
+            }
+        });
+        return indexes;
+    }
+
+    firstSelectedItem() {
+        return this.selectedItems.values().next().value;
+    }
+
+    constructor(
+        items: T[],
+        readonly mode: SelectMode = SelectMode.radio,
+        selectedItems?: T[],
+    ) {
+        this.items = items;
+        this.selectedItems = new Set(selectedItems ?? []);
+    }
+}

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

@@ -0,0 +1,9 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { Result } from "./result";
+
+export interface IConverter<TFrom = unknown, TTo = string> {
+    convert(value: TFrom): Result<TTo>;
+    convertBack?(value: TTo): Result<TFrom>;
+}

package/packages/chili-core/src/foundation/deepObserver.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 IPropertyChanged, isPropertyChanged } from "./observer";
+import { Result } from "./result";
+
+export type DeepPropertyChangedHandler = (path: string, source: IPropertyChanged, oldValue: any) => void;
+
+export type SourceHandler = {
+    handler: DeepPropertyChangedHandler;
+    sources: {
+        source: IPropertyChanged;
+        prefix: string | undefined;
+    }[];
+};
+
+export class DeepObserver {
+    private static readonly handlers = new Map<
+        IPropertyChanged,
+        Map<DeepPropertyChangedHandler, SourceHandler>
+    >();
+
+    static getPathValue(instance: IPropertyChanged, path: string): Result<any> {
+        const parts = path.split(".");
+
+        let value = instance;
+        for (let i = 0; i < parts.length; i++) {
+            value = (value as any)[parts[i]];
+            if (i < parts.length - 1 && !isPropertyChanged(value)) {
+                return Result.err(`Path ${path} is not valid`);
+            }
+        }
+
+        return Result.ok(value);
+    }
+
+    static addDeepPropertyChangedHandler(instance: IPropertyChanged, handler: DeepPropertyChangedHandler) {
+        const sourceHandler = DeepObserver.getOrInitHandler(instance, handler);
+        DeepObserver.deepHandlePropertyChanged(sourceHandler, instance);
+    }
+
+    static deepHandlePropertyChanged(
+        sourceHandler: SourceHandler,
+        source: IPropertyChanged,
+        prefix?: string,
+    ) {
+        source.onPropertyChanged(sourceHandler.handler);
+        sourceHandler.sources.push({ source, prefix });
+
+        const keys = Object.keys(Object.getOwnPropertyDescriptors(Object.getPrototypeOf(source)));
+        for (const key of keys) {
+            if (key === "constructor" || key.startsWith("_")) {
+                continue;
+            }
+            const subSource = (source as any)[key];
+            if (isPropertyChanged(subSource)) {
+                DeepObserver.deepHandlePropertyChanged(
+                    sourceHandler,
+                    subSource,
+                    prefix ? `${prefix}.${key}` : key,
+                );
+            }
+        }
+    }
+
+    static removeDeepPropertyChangedHandler(instance: IPropertyChanged, handler: DeepPropertyChangedHandler) {
+        const handlerMap = DeepObserver.handlers.get(instance);
+        if (!handlerMap) {
+            return;
+        }
+
+        const sourceHandler = handlerMap.get(handler);
+        if (!sourceHandler) {
+            DeepObserver.handlers.delete(instance);
+            return;
+        }
+
+        sourceHandler.sources.forEach((item) => {
+            item.source.removePropertyChanged(sourceHandler.handler);
+        });
+
+        handlerMap.delete(handler);
+        if (handlerMap.size === 0) {
+            DeepObserver.handlers.delete(instance);
+        }
+    }
+
+    private static getOrInitHandler(instance: IPropertyChanged, deepHandler: DeepPropertyChangedHandler) {
+        let handlerMap = DeepObserver.handlers.get(instance);
+        if (!handlerMap) {
+            handlerMap = new Map();
+            DeepObserver.handlers.set(instance, handlerMap);
+        }
+
+        let sourceHandler = handlerMap.get(deepHandler);
+        if (sourceHandler) {
+            sourceHandler.sources.forEach((item) => {
+                item.source.removePropertyChanged(sourceHandler!.handler);
+            });
+        }
+
+        sourceHandler = DeepObserver.initSourceHandler(instance, deepHandler);
+        handlerMap.set(deepHandler, sourceHandler);
+        return sourceHandler;
+    }
+
+    private static initSourceHandler(instance: IPropertyChanged, deepHandler: DeepPropertyChangedHandler) {
+        const handler = (property: string, target: IPropertyChanged, oldValue: any) => {
+            const sourceHandler = DeepObserver.handlers.get(instance)?.get(deepHandler);
+            if (!sourceHandler) {
+                return;
+            }
+
+            const source = sourceHandler.sources.find((x) => x.source === target);
+            if (!source) {
+                return;
+            }
+
+            const prefix = source.prefix ? `${source.prefix}.${property}` : property;
+            DeepObserver.updateHandlers(sourceHandler, target, property, prefix);
+
+            deepHandler(prefix, instance, oldValue);
+        };
+        return {
+            handler,
+            sources: [],
+        };
+    }
+
+    private static updateHandlers(
+        sourceHandler: SourceHandler,
+        target: IPropertyChanged,
+        property: string,
+        prefix: string | undefined,
+    ) {
+        const value = (target as any)[property];
+        if (value === undefined && prefix !== undefined) {
+            const sources = [];
+            for (const source of sourceHandler.sources) {
+                if (source.prefix?.startsWith(prefix)) {
+                    source.source.removePropertyChanged(sourceHandler.handler);
+                } else {
+                    sources.push(source);
+                }
+            }
+            sourceHandler.sources = sources;
+            return;
+        }
+
+        if (isPropertyChanged(value)) {
+            DeepObserver.deepHandlePropertyChanged(sourceHandler, value, prefix);
+        }
+    }
+}

package/packages/chili-core/src/foundation/disposable.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 interface IDisposable {
+    dispose(): void;
+}
+
+export namespace IDisposable {
+    export function isDisposable(value: unknown): value is IDisposable {
+        return (
+            value != null &&
+            typeof value === "object" &&
+            "dispose" in value &&
+            typeof (value as IDisposable).dispose === "function" &&
+            (value as IDisposable).dispose.length === 0
+        );
+    }
+}

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

@@ -0,0 +1,9 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export interface RecentDocumentDTO {
+    id: string;
+    name: string;
+    date: number;
+    image: string;
+}

package/packages/chili-core/src/foundation/equalityComparer.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 interface IEqualityComparer<T> {
+    equals(left: T, right: T): boolean;
+}

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

@@ -0,0 +1,36 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { IDisposable } from "./disposable";
+
+export interface Deletable {
+    delete(): void;
+}
+
+export namespace Deletable {
+    export function isDeletable(value: unknown): value is Deletable {
+        return typeof (value as any)?.delete === "function" && (value as any).delete.length === 0;
+    }
+}
+
+export const gc = <R>(action: (collect: <T extends Deletable | IDisposable>(resource: T) => T) => R): R => {
+    const resources = new Set<Deletable | IDisposable>();
+
+    const collectResource = <T extends Deletable | IDisposable>(resource: T) => {
+        resources.add(resource);
+        return resource;
+    };
+
+    try {
+        return action(collectResource);
+    } finally {
+        for (const resource of resources) {
+            if (Deletable.isDeletable(resource)) {
+                resource.delete();
+            } else if (IDisposable.isDisposable(resource)) {
+                resource.dispose();
+            }
+        }
+        resources.clear();
+    }
+};

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

@@ -0,0 +1,237 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { INode, INodeLinkedList } from "../model";
+import type { IDisposable } from "./disposable";
+
+export interface IHistoryRecord extends IDisposable {
+    readonly name: string;
+    undo(): void;
+    redo(): void;
+}
+
+export class History implements IDisposable {
+    private readonly _undos: IHistoryRecord[] = [];
+    private readonly _redos: IHistoryRecord[] = [];
+
+    disabled = false;
+    undoLimits = 50;
+
+    #isUndoing = false;
+    get isUndoing() {
+        return this.#isUndoing;
+    }
+    #isRedoing = false;
+    get isRedoing() {
+        return this.#isRedoing;
+    }
+
+    dispose(): void {
+        this._redos.forEach((record) => record.dispose());
+        this._undos.forEach((record) => record.dispose());
+        this.clear();
+    }
+
+    private clear(): void {
+        this._undos.length = 0;
+        this._redos.length = 0;
+    }
+
+    add(record: IHistoryRecord) {
+        if (this.disabled) return;
+
+        this._redos.length = 0;
+        this._undos.push(record);
+
+        if (this._undos.length > this.undoLimits) {
+            const removed = this._undos.shift();
+            removed?.dispose();
+        }
+    }
+
+    undoCount() {
+        return this._undos.length;
+    }
+
+    redoCount() {
+        return this._redos.length;
+    }
+
+    undo() {
+        this.#isUndoing = true;
+        this.tryOperate(
+            () => {
+                const record = this._undos.pop();
+                if (!record) return;
+
+                record.undo();
+                this._redos.push(record);
+            },
+            () => {
+                this.#isUndoing = false;
+            },
+        );
+    }
+
+    redo() {
+        this.#isRedoing = true;
+        this.tryOperate(
+            () => {
+                const record = this._redos.pop();
+                if (!record) return;
+
+                record.redo();
+                this._undos.push(record);
+            },
+            () => {
+                this.#isRedoing = false;
+            },
+        );
+    }
+
+    private tryOperate(action: () => void, onFinally: () => void) {
+        const previousState = this.disabled;
+        this.disabled = true;
+        try {
+            action();
+        } finally {
+            this.disabled = previousState;
+            onFinally();
+        }
+    }
+}
+
+export class PropertyHistoryRecord implements IHistoryRecord {
+    readonly name: string;
+    constructor(
+        readonly object: any,
+        readonly property: string | symbol | number,
+        readonly oldValue: any,
+        readonly newValue: any,
+    ) {
+        this.name = `change ${String(property)} property`;
+    }
+
+    dispose(): void {}
+
+    undo(): void {
+        this.object[this.property] = this.oldValue;
+    }
+
+    redo(): void {
+        this.object[this.property] = this.newValue;
+    }
+}
+
+export enum NodeAction {
+    add,
+    remove,
+    move,
+    transfer,
+    insertAfter,
+    insertBefore,
+}
+
+export interface NodeRecord {
+    node: INode;
+    action: NodeAction;
+    oldParent?: INodeLinkedList;
+    oldPrevious?: INode;
+    newParent?: INodeLinkedList;
+    newPrevious?: INode;
+}
+
+export class NodeLinkedListHistoryRecord implements IHistoryRecord {
+    readonly name: string;
+
+    constructor(readonly records: NodeRecord[]) {
+        this.name = "change node";
+    }
+
+    dispose(): void {
+        this.records.forEach((record) => {
+            if (record.action === NodeAction.remove) {
+                record.node.dispose();
+            }
+        });
+        this.records.length = 0;
+    }
+
+    private handleUndo(record: NodeRecord): void {
+        switch (record.action) {
+            case NodeAction.add:
+                record.newParent?.remove(record.node);
+                break;
+            case NodeAction.remove:
+                record.oldParent?.add(record.node);
+                break;
+            case NodeAction.transfer:
+                record.oldParent?.add(record.node);
+                break;
+            case NodeAction.move:
+                record.newParent?.move(record.node, record.oldParent!, record.oldPrevious);
+                break;
+            case NodeAction.insertAfter:
+                record.newParent?.remove(record.node);
+                break;
+            case NodeAction.insertBefore:
+                record.newParent?.remove(record.node);
+                break;
+        }
+    }
+
+    private handleRedo(record: NodeRecord): void {
+        switch (record.action) {
+            case NodeAction.add:
+                record.newParent?.add(record.node);
+                break;
+            case NodeAction.remove:
+                record.oldParent?.remove(record.node);
+                break;
+            case NodeAction.transfer:
+                record.oldParent?.transfer(record.node);
+                break;
+            case NodeAction.move:
+                record.oldParent?.move(record.node, record.newParent!, record.newPrevious);
+                break;
+            case NodeAction.insertAfter:
+                record.newParent?.insertAfter(record.newPrevious, record.node);
+                break;
+            case NodeAction.insertBefore:
+                record.newParent?.insertBefore(record.newPrevious?.nextSibling, record.node);
+                break;
+        }
+    }
+
+    undo(): void {
+        for (let i = this.records.length - 1; i >= 0; i--) {
+            this.handleUndo(this.records[i]);
+        }
+    }
+
+    redo(): void {
+        this.records.forEach((record) => this.handleRedo(record));
+    }
+}
+
+export class ArrayRecord implements IHistoryRecord {
+    readonly records: Array<IHistoryRecord> = [];
+
+    constructor(readonly name: string) {}
+
+    dispose(): void {
+        this.records.forEach((r) => r.dispose());
+    }
+
+    undo() {
+        for (let index = this.records.length - 1; index >= 0; index--) {
+            this.records[index].undo();
+        }
+    }
+
+    redo() {
+        for (const record of this.records) {
+            record.redo();
+        }
+    }
+}

package/packages/chili-core/src/foundation/id.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.
+
+// Copy from nanoid: https://github.com/ai/nanoid/blob/main/non-secure/index.js
+
+// This alphabet uses `A-Za-z0-9_-` symbols.
+// The order of characters is optimized for better gzip and brotli compression.
+// References to the same file (works both for gzip and brotli):
+// `'use`, `andom`, and `rict'`
+// References to the brotli default dictionary:
+// `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
+const alphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+export class Id {
+    static generate(size = 21) {
+        let id = "";
+        // A compact alternative for `for (var i = 0; i < step; i++)`.
+        let i = size;
+        while (i--) {
+            // `| 0` is more compact and faster than `Math.floor()`.
+            id += alphabet[(Math.random() * 64) | 0];
+        }
+        return id;
+    }
+}