sia-reactor 0.0.19 → 0.0.21

package/dist/index.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
+// src/ts/index.ts
 var index_exports = {};
 __export(index_exports, {
   CTX: () => CTX,
@@ -53,8 +53,10 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/consts.ts
+// src/ts/core/consts.ts
 var CTX = {
+  /** Flag indicating whether the application is running in development mode. */
+  isDevEnv: "undefined" !== typeof process ? process.env.NODE_ENV !== "production" : true,
   /** active `Autotracker` instance, override for automatic dependency collection on `Reactor` traps. */
   autotracker: null
 };
@@ -73,7 +75,7 @@ var NIL = Object.freeze({});
 var NOOP = () => {
 };
 
-// src/utils/obj.ts
+// src/ts/utils/obj.ts
 var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
 function isObj(obj, arraycheck = true) {
   return "object" === typeof obj && obj !== null && (arraycheck ? !Array.isArray(obj) : true);
@@ -189,7 +191,7 @@ function nuke(target) {
   }
 }
 
-// src/core/event.ts
+// src/ts/core/event.ts
 var ReactorEvent = class _ReactorEvent {
   /** No active propagation phase. */
   static NONE = 0;
@@ -312,7 +314,7 @@ var ReactorEvent = class _ReactorEvent {
   }
 };
 
-// src/core/reactor.ts
+// src/ts/core/reactor.ts
 var Reactor = class {
   log = NOOP;
   core;
@@ -340,27 +342,27 @@ var Reactor = class {
   listeners;
   /**
    * Creates a new Reactor instance.
-   * @param object Initial state object.
+   * @param target Initial state target.
    * @param build Reactor bootstrap/build configuration.
    * @example
    * const rtr = new Reactor({ count: 0 });
    */
-  constructor(object = {}, build) {
+  constructor(target = {}, build) {
     this[INERTIA] = true;
     this.config = { crossRealms: false, smartCloning: false, eventBubbling: true, lineageTracing: false, preserveContext: false, equalityFunction: Object.is, batchingFunction: RTR_BATCH, ...build };
-    this.core = this.proxied(object);
+    this.core = this.proxied(target);
     if (build) this.canLog = !!build.debug;
   }
-  proxied(obj, rejectable = false, indiffable = false, parent, key, path) {
-    if (!obj || "object" !== typeof obj) return obj;
-    obj = obj[RAW] || obj;
-    if (this.config.referenceTracking && parent && key && !this.link(obj, parent, key, false)) return obj;
-    const cached = this.proxyCache.get(obj);
+  proxied(target, rejectable = false, indiffable = false, parent, key, path) {
+    if (!target || "object" !== typeof target) return target;
+    target = target[RAW] || target;
+    if (this.config.referenceTracking && parent && key && !this.link(target, parent, key, false)) return target;
+    const cached = this.proxyCache.get(target);
     if (cached) return cached;
-    if (obj[INERTIA] || !canHandle(obj, this.config, false)) return obj;
-    rejectable ||= obj[REJECTABLE];
-    indiffable ||= obj[INDIFFABLE];
-    const proxy = new Proxy(obj, {
+    if (target[INERTIA] || !canHandle(target, this.config, false)) return target;
+    rejectable ||= target[REJECTABLE];
+    indiffable ||= target[INDIFFABLE];
+    const proxy = new Proxy(target, {
       // Robust Proxy handler
       get: (object, key2, receiver) => {
         if (key2 === RAW) return this.log(`\u{1F440} [Reactor \`get\` Trap] Peeked at ${object}`), object;
@@ -373,10 +375,10 @@ var Reactor = class {
           for (let i = 0, len = this.config.lineageTracing ? paths.length : 1; i < len; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.getters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, key: keyStr, keyExisted: true, object: receiver }, payload = { type: "get", target, currentTarget: target, root: this.core, rejectable };
+            const target2 = { path: currPath, value, key: keyStr, hadKey: true, object: receiver }, payload = { type: "get", target: target2, currentTarget: target2, root: this.core, rejectable };
             if (cords) value = this.mediate(currPath, payload, "get", cords);
             if (!wildcords) continue;
-            target.value = value;
+            target2.value = value;
             value = this.mediate("*", payload, "get", wildcords);
           }
         }
@@ -384,7 +386,7 @@ var Reactor = class {
       },
       set: (object, key2, value, receiver) => {
         let unchanged, safeValue, safeOldValue, terminated = false;
-        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), keyExisted = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
+        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), hadKey = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
         this.log(`\u270F\uFE0F [Reactor \`set\` Trap] Initiated for "${keyStr}" on "${paths}"`), CTX.autotracker?.track(fullPath, this, true);
         if (this.config.referenceTracking || !indiffable) {
           safeOldValue = oldValue?.[RAW] || oldValue;
@@ -398,13 +400,13 @@ var Reactor = class {
           for (let i = 0; i < loopLen; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.setters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver }, payload = { type: "set", target, currentTarget: target, root: this.core, terminated, rejectable };
+            const target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver }, payload = { type: "set", target: target2, currentTarget: target2, root: this.core, terminated, rejectable };
             if (cords) {
               const result2 = this.mediate(currPath, payload, "set", cords);
               if (!(terminated ||= payload.terminated)) value = result2;
             }
             if (!wildcords) continue;
-            target.value = value;
+            target2.value = value;
             const result = this.mediate("*", payload, "set", wildcords);
             if (!(terminated ||= payload.terminated)) value = result;
           }
@@ -415,14 +417,14 @@ var Reactor = class {
         if (this.config.referenceTracking && !unchanged) this.config.smartCloning && this.stamp(object), this.unlink(safeOldValue, object, keyStr), this.link(safeValue, object, keyStr);
         if (this.watchers || this.listeners)
           for (let i = 0; i < loopLen; i++) {
-            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver };
-            this.notify(currPath, { type: "set", target, currentTarget: target, root: this.core, terminated, rejectable });
+            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver };
+            this.notify(currPath, { type: "set", target: target2, currentTarget: target2, root: this.core, terminated, rejectable });
           }
         return true;
       },
       deleteProperty: (object, key2) => {
         let value, receiver = this.proxyCache.get(object), terminated = false;
-        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), keyExisted = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
+        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), hadKey = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
         this.log(`\u{1F5D1}\uFE0F [Reactor \`deleteProperty\` Trap] Initiated for "${keyStr}" on "${paths}"`), CTX.autotracker?.track(fullPath, this, true);
         if (this.config.deleteProperty) terminated = (value = this.config.deleteProperty(object, key2, oldValue, receiver, paths)) === TERMINATOR;
         if (this.deleters) {
@@ -430,7 +432,7 @@ var Reactor = class {
           for (let i = 0; i < loopLen; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.deleters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver }, payload = { type: "delete", target, currentTarget: target, root: this.core, rejectable };
+            const target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver }, payload = { type: "delete", target: target2, currentTarget: target2, root: this.core, rejectable };
             if (cords) {
               const result2 = this.mediate(currPath, payload, "delete", cords);
               if (!(terminated ||= payload.terminated)) value = result2;
@@ -446,8 +448,8 @@ var Reactor = class {
         if (this.config.referenceTracking) this.config.smartCloning && this.stamp(object), this.unlink(oldValue?.[RAW] || oldValue, object, keyStr);
         if (this.watchers || this.listeners)
           for (let i = 0; i < loopLen; i++) {
-            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver };
-            this.notify(currPath, { type: "delete", target, currentTarget: target, root: this.core, rejectable });
+            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver };
+            this.notify(currPath, { type: "delete", target: target2, currentTarget: target2, root: this.core, rejectable });
           }
         return true;
       },
@@ -473,7 +475,7 @@ var Reactor = class {
         return ownKeys;
       }
     });
-    return this.proxyCache.set(obj, proxy), proxy;
+    return this.proxyCache.set(target, proxy), proxy;
   }
   trace(target, path, paths = [], seen = /* @__PURE__ */ new WeakSet()) {
     if (Object.is(target, this.core[RAW] || this.core)) return paths.push(path), paths;
@@ -565,7 +567,7 @@ var Reactor = class {
   fire([path, object, value], e, isCapture, cords = this.listeners.get(path)) {
     if (!cords) return;
     e.type = path !== e.target.path ? "update" : e.staticType;
-    e.currentTarget = { path, value, oldValue: e.type !== "update" ? e.target.oldValue : void 0, key: e.type !== "update" ? path : path.slice(path.lastIndexOf(".") + 1) || "", keyExisted: e.type !== "update" ? e.target.keyExisted : true, object };
+    e.currentTarget = { path, value, oldValue: e.type !== "update" ? e.target.oldValue : void 0, key: e.type !== "update" ? path : path.slice(path.lastIndexOf(".") + 1) || "", hadKey: e.type !== "update" ? e.target.hadKey : true, object };
     for (let i = 0, len = cords.length, tDepth; i < len; i++) {
       if (e.immediatePropagationStopped) break;
       if (cords[i].capture !== isCapture) continue;
@@ -620,21 +622,20 @@ var Reactor = class {
   }
   getContext(path) {
     const lastDot = path.lastIndexOf("."), value = getAny(this.core, path), object = lastDot === -1 ? this.core : getAny(this.core, path.slice(0, lastDot));
-    return { path, value, key: path.slice(lastDot + 1) || "", keyExisted: true, object };
+    return { path, value, key: path.slice(lastDot + 1) || "", hadKey: true, object };
   }
   bindSignal(cord, sig) {
     if (sig) sig.aborted ? cord.clup() : sig.addEventListener("abort", cord.clup, { once: true });
     return cord.sclup = !sig || sig.aborted ? NOOP : () => sig.removeEventListener("abort", cord.clup), cord.clup;
   }
-  cloned(obj, raw, seen = /* @__PURE__ */ new WeakMap()) {
-    if (!obj || "object" !== typeof obj) return obj;
-    obj = obj[RAW] || obj;
-    const cloned = seen.get(obj);
+  cloned(target, raw, seen = /* @__PURE__ */ new WeakMap()) {
+    if (!target || "object" !== typeof target) return target;
+    const obj = target[RAW] || target, cloned = seen.get(obj);
     if (cloned) return cloned;
     if (!canHandle(obj, this.config, false)) return obj;
     const version = obj[VERSION] || 0, cached = !raw && this.config.smartCloning && (this.snapCache ??= /* @__PURE__ */ new WeakMap()).get(obj);
     if (cached && obj[SSVERSION] === version) return cached;
-    const clone = !raw ? this.config.preserveContext ? Object.create(Object.getPrototypeOf(obj)) : Array.isArray(obj) ? [] : {} : obj[RAW] || obj;
+    const clone = !raw ? this.config.preserveContext ? Object.create(Object.getPrototypeOf(obj)) : Array.isArray(obj) ? [] : {} : obj;
     seen.set(obj, clone);
     const keys = this.config.preserveContext ? Reflect.ownKeys(obj) : Object.keys(obj);
     for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = this.cloned(obj[keys[i]], raw, seen);
@@ -818,19 +819,8 @@ var Reactor = class {
     for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, callback) && cords[i].capture === capture) return cords[i].sclup(), cords.splice((len--, i--), 1), !cords.length && this.listeners.delete(path), true;
     return false;
   }
-  /**
-   * Creates a snapshot; possibly clone of state (or a state branch).
-   * You could alternatively use or serialize your proxied state "as is" except the environment demands no proxies or new references.
-   * @param raw Use raw (deep unproxied & uncloned) version of branch.
-   * @param branch Branch to clone.
-   * @returns Snapshot deep or smart (structurally shared) clone.
-   * @example
-   * const snap = rtr.snapshot();
-   * @example
-   * const snap = rtr.snapshot(false, rtr.core.history.past);
-   */
-  snapshot(raw = !this.config.smartCloning, branch = this.core) {
-    return this.cloned(branch, raw);
+  snapshot(raw = !this.config.smartCloning, branch) {
+    return this.cloned(arguments.length < 2 ? this.core : branch, raw);
   }
   /**
    * Cascades object updates into direct child paths.
@@ -881,11 +871,11 @@ var Reactor = class {
   }
 };
 
-// src/core/mixins.ts
-var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "cascade", "snapshot", "reset", "destroy"];
+// src/ts/core/mixins.ts
+var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "snapshot", "cascade", "plugIn", "reset", "destroy"];
 function reactive(target, build, preferences = NIL) {
   if ("__Reactor__" in target) return target;
-  const descriptors = {}, rtr = target instanceof Reactor ? target : new Reactor(target, build), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(preferences.prefix || preferences.suffix);
+  const descriptors = {}, rtr = getReactor(target, true, build), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(preferences.prefix || preferences.suffix);
   for (let i = 0, len = methods.length; i < len; i++) {
     let key = methods[i];
     if (hasAffix) (preferences.whitelist?.includes(key) ?? true) && (key = `${preferences.prefix || ""}${key}${preferences.suffix || ""}`);
@@ -922,6 +912,9 @@ function stable(target) {
 function isVolatile(target) {
   return !!getRaw(target)[INDIFFABLE];
 }
+function getReactor(target, create = false, build) {
+  return (target instanceof Reactor ? target : target.__Reactor__) || (create ? new Reactor(target, build) : void 0);
+}
 function getRaw(target) {
   return target?.[RAW] || target;
 }

package/dist/index.d.cts

@@ -1 +1 @@
-export { C as CTX, q as ChildPaths, D as DeepKeys, r as DeepMerge, t as DeepPartial, u as DeepRequired, v as Deleter, x as DeleterRecord, y as DirectPayload, z as EVT_OPTS, F as EVT_WARN, E as EffectOptions, G as Getter, H as GetterRecord, J as INDIFFABLE, K as INERTIA, I as Inert, L as Intent, M as Listener, N as ListenerOptions, O as ListenerOptionsTuple, Q as ListenerRecord, S as Live, T as NIL, U as NOOP, V as NoTraverse, X as PathBranch, Y as PathBranchValue, Z as PathKey, _ as PathLeaf, o as PathValue, P as Paths, $ as Payload, a0 as Primitive, a1 as RAW, a2 as REJECTABLE, a as REvent, a3 as RTR_BATCH, a4 as RTR_LOG, l as Reactive, a5 as ReactivePreferences, R as Reactor, a6 as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-C2hyIh0K.cjs';
+export { C as CTX, r as ChildPaths, D as DeepKeys, t as DeepMerge, u as DeepPartial, v as DeepRequired, x as Deleter, y as DeleterRecord, z as DirectPayload, F as EVT_OPTS, G as EVT_WARN, E as EffectOptions, H as Getter, J as GetterRecord, K as INDIFFABLE, L as INERTIA, I as Inert, M as Intent, N as Listener, O as ListenerOptions, Q as ListenerOptionsTuple, S as ListenerRecord, T as Live, U as NIL, V as NOOP, X as NoTraverse, Y as PathBranch, Z as PathBranchValue, _ as PathKey, $ as PathLeaf, q as PathValue, P as Paths, a0 as Payload, a1 as Primitive, a2 as RAW, a3 as REJECTABLE, a as REvent, a4 as RTR_BATCH, a5 as RTR_LOG, R as Reactive, a6 as ReactivePreferences, b as Reactor, o as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-Oie9hhE8.cjs';

package/dist/index.d.ts

@@ -1 +1 @@
-export { C as CTX, q as ChildPaths, D as DeepKeys, r as DeepMerge, t as DeepPartial, u as DeepRequired, v as Deleter, x as DeleterRecord, y as DirectPayload, z as EVT_OPTS, F as EVT_WARN, E as EffectOptions, G as Getter, H as GetterRecord, J as INDIFFABLE, K as INERTIA, I as Inert, L as Intent, M as Listener, N as ListenerOptions, O as ListenerOptionsTuple, Q as ListenerRecord, S as Live, T as NIL, U as NOOP, V as NoTraverse, X as PathBranch, Y as PathBranchValue, Z as PathKey, _ as PathLeaf, o as PathValue, P as Paths, $ as Payload, a0 as Primitive, a1 as RAW, a2 as REJECTABLE, a as REvent, a3 as RTR_BATCH, a4 as RTR_LOG, l as Reactive, a5 as ReactivePreferences, R as Reactor, a6 as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-C2hyIh0K.js';
+export { C as CTX, r as ChildPaths, D as DeepKeys, t as DeepMerge, u as DeepPartial, v as DeepRequired, x as Deleter, y as DeleterRecord, z as DirectPayload, F as EVT_OPTS, G as EVT_WARN, E as EffectOptions, H as Getter, J as GetterRecord, K as INDIFFABLE, L as INERTIA, I as Inert, M as Intent, N as Listener, O as ListenerOptions, Q as ListenerOptionsTuple, S as ListenerRecord, T as Live, U as NIL, V as NOOP, X as NoTraverse, Y as PathBranch, Z as PathBranchValue, _ as PathKey, $ as PathLeaf, q as PathValue, P as Paths, a0 as Payload, a1 as Primitive, a2 as RAW, a3 as REJECTABLE, a as REvent, a4 as RTR_BATCH, a5 as RTR_LOG, R as Reactive, a6 as ReactivePreferences, b as Reactor, o as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-Oie9hhE8.js';

package/dist/index.js

@@ -1,4 +1,6 @@
 import {
+  Reactor,
+  ReactorEvent,
   getRaw,
   getSnapshotVersion,
   getVersion,
@@ -13,11 +15,7 @@ import {
   stable,
   state,
   volatile
-} from "./chunk-KIQP7G7W.js";
-import {
-  Reactor,
-  ReactorEvent
-} from "./chunk-Q2AKMIHN.js";
+} from "./chunk-2WBPGSRL.js";
 import {
   CTX,
   EVT_OPTS,
@@ -33,7 +31,7 @@ import {
   SSVERSION,
   TERMINATOR,
   VERSION
-} from "./chunk-4MJUBEI7.js";
+} from "./chunk-DP74DVRT.js";
 export {
   CTX,
   EVT_OPTS,