j-templates 8.0.13 → 8.0.14

package/Utils/decorators.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * This module provides decorators for managing state, computed values, and dependency injection in components.
  * These decorators are designed to work with observable data structures, allowing for efficient updates and notifications.
@@ -57,19 +56,9 @@
  * console.log(list === list2);    // @Computed: true, @Scope: false
  * ```
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bound = void 0;
-exports.Computed = Computed;
-exports.ComputedAsync = ComputedAsync;
-exports.State = State;
-exports.Value = Value;
-exports.Scope = Scope;
-exports.Watch = Watch;
-exports.Inject = Inject;
-exports.Destroy = Destroy;
-const observableScope_1 = require("../Store/Tree/observableScope");
-const observableNode_1 = require("../Store/Tree/observableNode");
-const Store_1 = require("../Store");
+import { ObservableScope, } from "../Store/Tree/observableScope";
+import { ObservableNode } from "../Store/Tree/observableNode";
+import { StoreAsync } from "../Store";
 /**
  * WeakMap for storing node instances and their associated properties.
  * @private
@@ -134,22 +123,22 @@ function GetDestroyArrayForPrototype(prototype, create = true) {
     return array;
 }
 function CreateStoreScope(getter, store, defaultValue) {
-    const getterScope = observableScope_1.ObservableScope.Gated(function () {
+    const getterScope = ObservableScope.Gated(function () {
         const value = getter();
-        return observableNode_1.ObservableNode.Clone(value);
+        return ObservableNode.Clone(value);
     });
-    observableScope_1.ObservableScope.Watch(getterScope, (scope) => {
-        const data = observableScope_1.ObservableScope.Peek(scope);
+    ObservableScope.Watch(getterScope, (scope) => {
+        const data = ObservableScope.Peek(scope);
         store.Write(data, "root");
     });
-    const data = observableScope_1.ObservableScope.Peek(getterScope);
+    const data = ObservableScope.Peek(getterScope);
     store.Write(data, "root");
-    const propertyScope = observableScope_1.ObservableScope.Create(() => {
+    const propertyScope = ObservableScope.Create(() => {
         return store.Get("root", defaultValue);
     });
-    observableScope_1.ObservableScope.OnDestroyed(propertyScope, function () {
-        observableScope_1.ObservableScope.Destroy(getterScope);
-        if (store instanceof Store_1.StoreAsync)
+    ObservableScope.OnDestroyed(propertyScope, function () {
+        ObservableScope.Destroy(getterScope);
+        if (store instanceof StoreAsync)
             store.Destroy();
     });
     return propertyScope;
@@ -170,11 +159,11 @@ function CreateStoreScope(getter, store, defaultValue) {
  * @returns The Gated scope whose value is the observable root node.
  */
 function CreateNodeScope(getter) {
-    const observableNode = observableNode_1.ObservableNode.Create({ root: null });
-    const getterScope = observableScope_1.ObservableScope.Gated(function () {
+    const observableNode = ObservableNode.Create({ root: null });
+    const getterScope = ObservableScope.Gated(function () {
         const value = getter();
-        const clonedValue = observableNode_1.ObservableNode.Clone(value);
-        observableNode_1.ObservableNode.Apply(observableNode, { root: clonedValue });
+        const clonedValue = ObservableNode.Clone(value);
+        ObservableNode.Apply(observableNode, { root: clonedValue });
         return observableNode.root;
     });
     return getterScope;
@@ -280,7 +269,7 @@ function CreateNodeScope(getter) {
  * @see {@link ObservableScope} for the Gated scope mechanism (batched, ===-gated updates)
  * @see {@link StoreSync} for the store-backed variant used by @ComputedAsync
  */
-function Computed() {
+export function Computed() {
     return function (target, propertyKey, descriptor) {
         return ComputedDecorator(target, propertyKey, descriptor);
     };
@@ -310,7 +299,7 @@ function ComputedDecorator(target, prop, descriptor) {
                 const propertyScope = CreateNodeScope(getter.bind(this));
                 scopeMap[propertyKey] = [propertyScope, undefined];
             }
-            return observableScope_1.ObservableScope.Value(scopeMap[propertyKey][0]);
+            return ObservableScope.Value(scopeMap[propertyKey][0]);
         },
     };
 }
@@ -405,7 +394,7 @@ function ComputedDecorator(target, prop, descriptor) {
  * @see {@link StoreAsync} for async store implementation
  * @see {@link ObservableScope.Create} for async function support
  */
-function ComputedAsync(defaultValue) {
+export function ComputedAsync(defaultValue) {
     return function (target, propertyKey, descriptor) {
         return ComputedAsyncDecorator(target, propertyKey, descriptor, defaultValue);
     };
@@ -433,10 +422,12 @@ function ComputedAsyncDecorator(target, prop, descriptor, defaultValue) {
         get: function () {
             const scopeMap = GetScopeMapForInstance(this);
             if (scopeMap[propertyKey] === undefined) {
-                const propertyScope = CreateStoreScope(getter.bind(this), new Store_1.StoreAsync(), defaultValue);
+                const worker = new Worker(new URL("../Store/Diff/defaultDiffTreeWorker.js", import.meta.url), { type: "module" });
+                const storeAsync = new StoreAsync(worker);
+                const propertyScope = CreateStoreScope(getter.bind(this), storeAsync, defaultValue);
                 scopeMap[propertyKey] = [propertyScope, undefined];
             }
-            return observableScope_1.ObservableScope.Value(scopeMap[propertyKey][0]);
+            return ObservableScope.Value(scopeMap[propertyKey][0]);
         },
     };
 }
@@ -498,7 +489,7 @@ function ComputedAsyncDecorator(target, prop, descriptor, defaultValue) {
  * @see {@link Computed} for derived/read-only values
  * @see {@link ObservableNode} for the proxy-based reactivity system
  */
-function State() {
+export function State() {
     return StateDecorator;
 }
 /**
@@ -514,13 +505,13 @@ function StateDecorator(target, propertyKey) {
         enumerable: true,
         get: function () {
             const map = GetNodeMapForInstance(this);
-            map[propertyKey] ??= observableNode_1.ObservableNode.Create({ root: undefined });
+            map[propertyKey] ??= ObservableNode.Create({ root: undefined });
             return map[propertyKey].root;
         },
         set: function (val) {
             const map = GetNodeMapForInstance(this);
             if (map[propertyKey] === undefined)
-                map[propertyKey] ??= observableNode_1.ObservableNode.Create({ root: val });
+                map[propertyKey] ??= ObservableNode.Create({ root: val });
             else
                 map[propertyKey].root = val;
         },
@@ -587,7 +578,7 @@ function StateDecorator(target, propertyKey) {
  * @see {@link Computed} for derived/read-only values
  * @see {@link ObservableScope} for the scope-based reactivity system
  */
-function Value() {
+export function Value() {
     return ValueDecorator;
 }
 /**
@@ -597,7 +588,7 @@ function Value() {
  * @returns An observable scope created from the tuple's value.
  */
 function CreateValueScope(tuple) {
-    return observableScope_1.ObservableScope.Basic(function () {
+    return ObservableScope.Basic(function () {
         return tuple[1];
     });
 }
@@ -616,14 +607,14 @@ function ValueDecorator(target, propertyKey) {
             const propertyMap = GetScopeMapForInstance(this);
             const tuple = (propertyMap[propertyKey] ??= [null, undefined]);
             tuple[0] ??= CreateValueScope(tuple);
-            return observableScope_1.ObservableScope.Value(tuple[0]);
+            return ObservableScope.Value(tuple[0]);
         },
         set: function (val) {
             const propertyMap = GetScopeMapForInstance(this);
             propertyMap[propertyKey] ??= [null, undefined];
             const tuple = propertyMap[propertyKey];
             tuple[1] = val;
-            observableScope_1.ObservableScope.Update(tuple[0]);
+            ObservableScope.Update(tuple[0]);
         },
     };
 }
@@ -746,7 +737,7 @@ function ValueDecorator(target, propertyKey) {
  * @see {@link ObservableScope} for the scope-based reactivity system
  * @see {@link scope} for inline computed scopes within @Scope
  */
-function Scope() {
+export function Scope() {
     return ScopeDecorator;
 }
 /**
@@ -772,8 +763,8 @@ function ScopeDecorator(target, propertyKey, descriptor) {
             propertyMap[propertyKey] ??= [null, undefined];
             const tuple = propertyMap[propertyKey];
             if (tuple[0] === null)
-                tuple[0] = observableScope_1.ObservableScope.Create(getter.bind(this));
-            return observableScope_1.ObservableScope.Value(tuple[0]);
+                tuple[0] = ObservableScope.Create(getter.bind(this));
+            return ObservableScope.Value(tuple[0]);
         },
     };
 }
@@ -833,7 +824,7 @@ function ScopeDecorator(target, propertyKey, descriptor) {
  * @see {@link Destroy} for automatic cleanup on component teardown
  * @see {@link Scope} for creating computed values to watch
  */
-function Watch(scope) {
+export function Watch(scope) {
     return function (target, propertyKey, descriptor) {
         return WatchDecorator(target, propertyKey, descriptor, scope);
     };
@@ -845,13 +836,13 @@ function WatchDecorator(target, propertyKey, descriptor, scopeFunction) {
         function scopeFunctionWrapper() {
             return scopeFunction(instance);
         }
-        const scope = observableScope_1.ObservableScope.Gated(scopeFunctionWrapper);
+        const scope = ObservableScope.Gated(scopeFunctionWrapper);
         const propertyMap = GetScopeMapForInstance(instance);
         propertyMap[propertyKey] = [scope, undefined];
-        observableScope_1.ObservableScope.Watch(scope, function (scope) {
-            instance[propertyKey](observableScope_1.ObservableScope.Value(scope));
+        ObservableScope.Watch(scope, function (scope) {
+            instance[propertyKey](ObservableScope.Value(scope));
         });
-        instance[propertyKey](observableScope_1.ObservableScope.Value(scope));
+        instance[propertyKey](ObservableScope.Value(scope));
         return instance;
     }
     const boundArray = GetBoundArrayForPrototype(target);
@@ -930,7 +921,7 @@ function WatchDecorator(target, propertyKey, descriptor, scopeFunction) {
  * @see {@link Injector} for the dependency injection system
  * @see {@link Component.Injector} for accessing the component's injector
  */
-function Inject(type) {
+export function Inject(type) {
     return function () {
         return InjectDecorator(type);
     };
@@ -1024,14 +1015,14 @@ function InjectDecorator(type) {
  * @see {@link Destroy.All} for the cleanup implementation
  * @see {@link Component.Destroy} for component lifecycle
  */
-function Destroy() {
+export function Destroy() {
     return DestroyDecorator;
 }
 /**
  * Bound namespace provides lifecycle hooks for component initialization.
  * Methods in this namespace are called after a component is attached to the DOM.
  */
-var Bound;
+export var Bound;
 (function (Bound) {
     /**
      * Binds all @Watch-decorated methods on a component instance.
@@ -1067,7 +1058,7 @@ var Bound;
             array[x](value);
     }
     Bound.All = All;
-})(Bound || (exports.Bound = Bound = {}));
+})(Bound || (Bound = {}));
 /**
  * Destroy namespace provides cleanup utilities for component teardown.
  * Methods in this namespace are called when a component is destroyed to prevent memory leaks.
@@ -1122,14 +1113,14 @@ var Bound;
         if (scopeMap !== undefined) {
             const values = Object.values(scopeMap);
             for (let x = 0; x < values.length; x++)
-                observableScope_1.ObservableScope.Destroy(values[x][0]);
+                ObservableScope.Destroy(values[x][0]);
         }
         const array = GetDestroyArrayForPrototype(Object.getPrototypeOf(value), false);
         for (let x = 0; array && x < array.length; x++)
             value[array[x]].Destroy();
     }
     Destroy.All = All;
-})(Destroy || (exports.Destroy = Destroy = {}));
+})(Destroy || (Destroy = {}));
 function DestroyDecorator(target, propertyKey) {
     const array = GetDestroyArrayForPrototype(target);
     array.push(propertyKey);

package/Utils/emitter.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Emitter = void 0;
-const array_1 = require("./array");
-const scheduling_1 = require("./scheduling");
+import { RemoveNulls } from "./array";
+import { _requestIdleCallback } from "./scheduling";
 const pendingCompactEmitters = new Set();
 function Compact(emitter) {
     if (emitter.length === 1 || emitter[0] === 0)
@@ -15,7 +12,7 @@ function ScheduleCompact() {
     if (compactScheduled)
         return;
     compactScheduled = true;
-    (0, scheduling_1._requestIdleCallback)(PerformCompact);
+    _requestIdleCallback(PerformCompact);
 }
 function PerformCompact() {
     compactScheduled = false;
@@ -30,7 +27,7 @@ function CompactEmitter(emitter) {
     emitter.splice(1, emitter[0]);
     emitter[0] = 0;
 }
-var Emitter;
+export var Emitter;
 (function (Emitter) {
     function Create() {
         return [0];
@@ -48,7 +45,7 @@ var Emitter;
             emitter[x]?.(...args);
         emitterStack.pop();
         if (modifiedDuringEmit.delete(emitter)) {
-            (0, array_1.RemoveNulls)(emitter);
+            RemoveNulls(emitter);
             emitter[0] = 0;
         }
     }
@@ -78,4 +75,4 @@ var Emitter;
         emitter[0] = 0;
     }
     Emitter.Clear = Clear;
-})(Emitter || (exports.Emitter = Emitter = {}));
+})(Emitter || (Emitter = {}));

package/Utils/functions.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsAsync = IsAsync;
 /**
  * Checks if a function is an async function.
  * @param func - The function to check
  * @returns true if the function is async, false otherwise
  */
-function IsAsync(func) {
+export function IsAsync(func) {
     return func && func[Symbol.toStringTag] === "AsyncFunction";
 }

package/Utils/index.js

@@ -1,21 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = void 0;
-__exportStar(require("./decorators"), exports);
-__exportStar(require("./animation"), exports);
-var injector_1 = require("./injector");
-Object.defineProperty(exports, "Injector", { enumerable: true, get: function () { return injector_1.Injector; } });
+export * from "./decorators";
+export * from "./animation";
+export { Injector } from "./injector";

package/Utils/injector.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injector = void 0;
 /**
  * Simple scoped dependency injection class. Manages types/instances as key/value pairs.
  */
-class Injector {
+export class Injector {
     constructor() {
         this.parent = Injector.Current();
         this.typeMap = new Map();
@@ -32,7 +29,6 @@ class Injector {
         return instance;
     }
 }
-exports.Injector = Injector;
 (function (Injector) {
     var scope = null;
     /**
@@ -62,4 +58,4 @@ exports.Injector = Injector;
         }
     }
     Injector.Scope = Scope;
-})(Injector || (exports.Injector = Injector = {}));
+})(Injector || (Injector = {}));

package/Utils/json.d.ts

@@ -8,15 +8,37 @@ export type JsonDiffResult<T = unknown> = {
     /** The new value at this path */
     value: unknown;
 }[];
-export type JsonDiffFactoryResult = ReturnType<typeof JsonDiffFactory>;
 /**
- * Factory that creates JSON utility functions for diffing, merging, and cloning.
- * @returns Object containing JsonDiff, JsonType, JsonDeepClone, and JsonMerge functions
+ * Determines the JSON type of a value.
+ * @param value - The value to check
+ * @returns "value" for primitives/null/undefined, "object" for plain objects, "array" for arrays
  */
-export declare function JsonDiffFactory(): {
-    JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>;
-    JsonType: (value: any) => "object" | "value" | "array";
-    JsonDeepClone: <T>(value: T, type?: string) => T;
-    JsonMerge: (source: unknown, patch: unknown) => unknown;
-};
-export declare const JsonDiff: <T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>) => JsonDiffResult<T>, JsonType: (value: any) => "object" | "value" | "array", JsonDeepClone: <T>(value: T, type?: string) => T, JsonMerge: (source: unknown, patch: unknown) => unknown;
+export declare function JsonType(value: any): "object" | "value" | "array";
+/**
+ * Deep merges a patch into a source value.
+ * - If types don't match, returns the patch
+ * - For objects: recursively merges properties, adds new properties
+ * - For arrays: maps over patch, merging with corresponding source elements
+ * @param source - The original value
+ * @param patch - The value to merge into source
+ * @returns The merged result
+ */
+export declare function JsonMerge(source: unknown, patch: unknown): unknown;
+/**
+ * Creates a deep clone of a JSON-compatible value.
+ * @template T - The type of the value to clone
+ * @param value - The value to clone
+ * @returns A deep clone of the value
+ */
+export declare function JsonDeepClone<T>(value: T, type?: string): T;
+/**
+ * Computes the differences between two JSON values.
+ * Returns an array of paths and values that changed from oldValue to newValue.
+ * @template T - The type of the JSON values being compared
+ * @param newValue - The new value
+ * @param oldValue - The old value to compare against
+ * @param rootPath - Optional dot-separated string for the base path (for internal recursion)
+ * @param initResult - Optional initial result array (for internal recursion)
+ * @returns Array of change records with path and new value
+ */
+export declare function JsonDiff<T>(newValue: T, oldValue: T, rootPath?: string, initResult?: JsonDiffResult<T>): JsonDiffResult<T>;