dazscript-framework 0.1.14 → 0.1.16

package/src/lib/frame-keys.ts

@@ -1,68 +1,68 @@
-import { find } from '@dsf/helpers/array-helper';
-
-export class PropertyKey {
-    index: number
-    frame: number = 0
-    time: DzTime
-    value: number
-
-    toJSON(): Object {
-        return {
-            index: this.index,
-            time: this.time.valueOf(),
-            frame: this.frame,
-            value: this.value,
-        }
-    }
-}
-
-export class PropertyKeys {
-    constructor(private _items: PropertyKey[]) {
-        if (!this._items) this._items = [];
-    }
-
-    forEach(callback: (key: PropertyKey) => any) {
-        this._items.forEach(key => {
-            callback(key);
-        });
-    }
-
-    get items(): PropertyKey[] {
-        return this._items;
-    }
-
-    get first(): PropertyKey | null {
-        return this._items[0]
-    }
-
-    get length(): number {
-        return this._items.length;
-    }
-
-    get current(): PropertyKey {
-        return find(this._items, k => k.time.valueOf() == Scene.getTime().valueOf())
-    }
-
-    get previous(): PropertyKey {
-        return find(this._items.sort((a, b) => b.index - a.index), k => k.time.valueOf() < Scene.getTime().valueOf())
-    }
-
-    get next(): PropertyKey {
-        return find(this._items, k => k.time.valueOf() > Scene.getTime().valueOf())
-    }
-
-    /**
-     * Given the animation frame number or time, return the property key
-     * @param frameorTime frame number or time
-     * @returns the property key
-     */
-    at(frameorTime: number | DzTime): PropertyKey | null {
-        return typeof frameorTime === 'number'
-            ? find(this._items, k => k.frame === frameorTime)
-            : find(this._items, k => k.time === frameorTime)
-    }
-
-    any(): boolean {
-        return this.items.length > 0
-    }
+import { find } from '@dsf/helpers/array-helper';
+
+export class PropertyKey {
+    index: number
+    frame: number = 0
+    time: DzTime
+    value: number
+
+    toJSON(): Object {
+        return {
+            index: this.index,
+            time: this.time.valueOf(),
+            frame: this.frame,
+            value: this.value,
+        }
+    }
+}
+
+export class PropertyKeys {
+    constructor(private _items: PropertyKey[]) {
+        if (!this._items) this._items = [];
+    }
+
+    forEach(callback: (key: PropertyKey) => any) {
+        this._items.forEach(key => {
+            callback(key);
+        });
+    }
+
+    get items(): PropertyKey[] {
+        return this._items;
+    }
+
+    get first(): PropertyKey | null {
+        return this._items[0]
+    }
+
+    get length(): number {
+        return this._items.length;
+    }
+
+    get current(): PropertyKey {
+        return find(this._items, k => k.time.valueOf() == Scene.getTime().valueOf())
+    }
+
+    get previous(): PropertyKey {
+        return find(this._items.sort((a, b) => b.index - a.index), k => k.time.valueOf() < Scene.getTime().valueOf())
+    }
+
+    get next(): PropertyKey {
+        return find(this._items, k => k.time.valueOf() > Scene.getTime().valueOf())
+    }
+
+    /**
+     * Given the animation frame number or time, return the property key
+     * @param frameorTime frame number or time
+     * @returns the property key
+     */
+    at(frameorTime: number | DzTime): PropertyKey | null {
+        return typeof frameorTime === 'number'
+            ? find(this._items, k => k.frame === frameorTime)
+            : find(this._items, k => k.time === frameorTime)
+    }
+
+    any(): boolean {
+        return this.items.length > 0
+    }
 }

package/src/lib/guid.ts

@@ -1,3 +1,3 @@
-export const createUID = (): string => {
-    return "uuid-" + ((new Date).getTime().toString(16) + Math.floor(1E7 * Math.random()).toString(16));
+export const createUID = (): string => {
+    return "uuid-" + ((new Date).getTime().toString(16) + Math.floor(1E7 * Math.random()).toString(16));
 }

package/src/lib/menu-item.ts

@@ -1,9 +1,10 @@
-export type MenuItem = {
-    description: string
-    shortcut: string
-    name: string
-    label: string
-    path: string
-    icon: string
-    hidden: boolean
-}
+export type MenuItem = {
+    description: string
+    shortcut: string
+    name: string
+    label: string
+    path: string
+    filePath?: string
+    icon: string
+    hidden: boolean
+}

package/src/lib/observable.ts

@@ -1,94 +1,147 @@
-export class Observable<T> {
-    protected _value: T;
-    private _beforeChange: (previous: T, current: T) => T
-    private _onChange: Array<(value: T) => void> = []
-    private _afterChange: (previous: T, current: T) => T
-    private _paused: boolean
-
-    constructor(value?: T, onChange?: (value: T) => void) {
-        this.value = value;
-        if (onChange)
-            this._onChange.push(onChange);
-    }
-
-    get value(): T {
-        return this._value;
-    }
-
-    set value(value: T) {
-        let previous = this._value
-        this._value = this._beforeChange?.(this._value, value) ?? value
-        if (!this._paused) this.trigger()
-        this._value = this._afterChange?.(previous, this._value) ?? this._value
-    }
-
-    connect(onChange: (value: T) => void): this {
-        if (this._onChange.indexOf(onChange) === -1) {
-            this._onChange.push(onChange)
-        }
-        return this
-    }
-
-    intercept(beforeChange: (previous: T, current: T) => T, afterChange?: (previous: T, current: T) => T): this {
-        this._beforeChange = beforeChange
-        this._afterChange = afterChange
-        return this
-    }
-
-    disconnect(onChange: (value: T) => void) {
-        const index = this._onChange.indexOf(onChange);
-        if (index > -1) {
-            this._onChange.splice(index, 1);
-        }
-    }
-
-    trigger(): void {
-        if (!this._paused)
-            this._onChange.forEach(callback => callback(this._value));
-    }
-
-    pause(callback?: () => void): void {
-        this._paused = true
-        callback?.()
-        this.resume()
-    }
-
-    resume(): void {
-        this._paused = false
-    }
-
-    toJSON() {
-        return this._value;
-    }
-}
-
-export class BooleanObservable extends Observable<boolean> {
-    private combined: BooleanObservable[] = []
-
-    combine(...observables: BooleanObservable[]): this {
-        observables.forEach((obs) => {
-            this.combined.push(obs)
-            obs.connect(_ => {
-                this._value = this.combined.every(b => b.value)
-            })
-        })
-        return this
-    }
-}
-
-
-// export class ObservableNumber extends Observable<number> {
-//     setMax(max: number): this {
-//         this.connect((value) => {
-//             if (value > max) value = max
-//         })
-//         return this
-//     }
-
-//     setMin(min: number): this {
-//         this.connect((value) => {
-//             if (value < min) value = min
-//         })
-//         return this
-//     }
-// }
+export class Observable<T> {
+    protected _value: T;
+    private _beforeChange?: (previous: T, current: T) => T;
+    private _afterChange?: (previous: T, current: T) => T;
+    private _onChange: Array<(value: T) => void> = [];
+    private _paused = false;
+
+    // NEW: guards + comparator
+    private _isSetting = false;
+    private _pendingValue?: T; // last requested value during an active set
+    private _equals: (a: T, b: T) => boolean;
+    private static readonly MAX_AFTER_CHANGE_DEPTH = 10;
+    private static readonly MAX_CHAINED_SETS = 100; // limit for cascading listener-driven sets
+
+    constructor(value?: T, onChange?: (value: T) => void, equals?: (a: T, b: T) => boolean) {
+        this._value = value as T;
+        if (onChange) this._onChange.push(onChange);
+        this._equals = equals ?? ((a, b) => a === b);
+    }
+
+    get value(): T { return this._value; }
+
+    set value(next: T) {
+        // Coalesce: if actively setting, just remember the latest requested value.
+        if (this._isSetting) { this._pendingValue = next; return; }
+
+        let currentRequested: T | undefined = next;
+        let chainedSets = 0;
+        let afterDepth = 0;
+
+        while (currentRequested !== undefined) {
+            const prev = this._value;
+            let candidate = this._beforeChange?.(prev, currentRequested) ?? currentRequested;
+            currentRequested = undefined; // consume
+
+            if (this._equals(prev, candidate)) {
+                // No actual change; ignore any pending identical value.
+                this._pendingValue = undefined;
+                break;
+            }
+
+            this._isSetting = true;
+            this._value = candidate;
+            if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
+
+            // Apply afterChange transformations (bounded)
+            let transformed = this._afterChange?.(prev, this._value);
+            while (transformed !== undefined && !this._equals(this._value, transformed)) {
+                afterDepth++;
+                if (afterDepth > Observable.MAX_AFTER_CHANGE_DEPTH) {
+                    this._isSetting = false;
+                    this._pendingValue = undefined;
+                    throw new Error(`Observable: _afterChange exceeded depth ${Observable.MAX_AFTER_CHANGE_DEPTH}. Possible loop.`);
+                }
+                this._value = transformed;
+                if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
+                transformed = this._afterChange?.(prev, this._value);
+            }
+
+            this._isSetting = false;
+
+            // If a listener requested a new value during this cycle, process it
+            if (this._pendingValue !== undefined && !this._equals(this._value, this._pendingValue)) {
+                currentRequested = this._pendingValue;
+                this._pendingValue = undefined;
+                chainedSets++;
+                if (chainedSets > Observable.MAX_CHAINED_SETS) {
+                    throw new Error(`Observable: Too many chained set operations (>${Observable.MAX_CHAINED_SETS}). Possible loop.`);
+                }
+            } else {
+                // Either no pending or it's same-value;
+                this._pendingValue = undefined;
+            }
+        }
+    }
+
+    connect(onChange: (value: T) => void): this {
+        if (this._onChange.indexOf(onChange) === -1) this._onChange.push(onChange);
+        return this;
+    }
+
+    intercept(
+        beforeChange: (previous: T, current: T) => T,
+        afterChange?: (previous: T, current: T) => T
+    ): this {
+        this._beforeChange = beforeChange;
+        this._afterChange = afterChange;
+        return this;
+    }
+
+    disconnect(onChange: (value: T) => void) {
+        const i = this._onChange.indexOf(onChange);
+        if (i > -1) this._onChange.splice(i, 1);
+    }
+
+    trigger(): void {
+        if (!this._paused) this._onChange.slice().forEach(cb => cb(this._value));
+    }
+
+    pause(callback?: () => void): void {
+        this._paused = true;
+        callback?.();
+        this.resume();
+    }
+    resume(): void { this._paused = false; }
+
+    // Optional: silent set (no callbacks) for derived/computed cases
+    setSilently(next: T): void { this._value = next; }
+
+    toJSON() { return this._value; }
+}
+
+export class BooleanObservable extends Observable<boolean> {
+    private combined: BooleanObservable[] = [];
+    private _isUpdatingFromCombined = false;
+
+    combine(...observables: BooleanObservable[]): this {
+        observables.forEach(obs => {
+            // Prevent circular references
+            if (obs === this) {
+                throw new Error('BooleanObservable: Cannot combine with itself');
+            }
+
+            this.combined.push(obs);
+            obs.connect(() => {
+                // Prevent circular updates
+                if (this._isUpdatingFromCombined) return;
+
+                this._isUpdatingFromCombined = true;
+                try {
+                    this.value = this.combined.every(b => b.value);
+                } finally {
+                    this._isUpdatingFromCombined = false;
+                }
+            });
+        });
+        // initialize once
+        this._isUpdatingFromCombined = true;
+        try {
+            this.value = this.combined.every(b => b.value);
+        } finally {
+            this._isUpdatingFromCombined = false;
+        }
+        return this;
+    }
+}
+

package/src/lib/set.ts

@@ -1,25 +1,50 @@
-export default class CustomSet<T> {
-    private items: Record<string, T> = {};
-
-    add(item: T): void {
-        const key = this.getKey(item);
-        this.items[key] = item;
-    }
-
-    has(item: T): boolean {
-        const key = this.getKey(item);
-        return key in this.items;
-    }
-
-    private getKey(item: T): string {
-        if (typeof item === 'object') {
-            // For object items, use a unique identifier (e.g., JSON string) as the key
-            return JSON.stringify(item);
-        }
-        return String(item);
-    }
-
-    values(): T[] {
-        return Object.values(this.items);
-    }
-}
+export default class CustomSet<T> {
+    private items: Record<string, T> = {};
+
+    add(item: T): void {
+        const key = this.getKey(item);
+        this.items[key] = item;
+    }
+
+    has(item: T): boolean {
+        const key = this.getKey(item);
+        return key in this.items;
+    }
+
+    remove(item: T): void {
+        const key = this.getKey(item);
+        delete this.items[key];
+    }
+
+    clear(): void {
+        this.items = {};
+    }
+
+    forEach(callback: (item: T) => void): void {
+        for (const key in this.items) {
+            if (this.items.hasOwnProperty(key)) {
+                callback(this.items[key]);
+            }
+        }
+    }
+
+    private getKey(item: T): string {
+        if (typeof item === 'object') {
+            // For object items, use a unique identifier (e.g., JSON string) as the key
+            return JSON.stringify(item);
+        }
+        return String(item);
+    }
+
+    values(): T[] {
+        let values: T[] = [];
+
+        for (const key in this.items) {
+            if (this.items.hasOwnProperty(key)) {
+                values.push(this.items[key]);
+            }
+        }
+
+        return values;
+    }
+}