@ng-org/alien-deepsignals 0.1.2-alpha.1

package/dist/core.js

@@ -0,0 +1,113 @@
+"use strict";
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSignal = exports.computed = exports.signal = exports._rawEffect = exports._rawSetCurrentSub = exports._rawGetCurrentSub = exports._rawEndBatch = exports._rawStartBatch = exports._rawComputed = exports._rawSignal = void 0;
+exports.batch = batch;
+/** Lightweight facade adding ergonomic helpers (.value/.peek/.get/.set) to native alien-signals function signals. */
+// Native re-exports for advanced usage.
+var alien_signals_1 = require("alien-signals");
+Object.defineProperty(exports, "_rawSignal", { enumerable: true, get: function () { return alien_signals_1.signal; } });
+Object.defineProperty(exports, "_rawComputed", { enumerable: true, get: function () { return alien_signals_1.computed; } });
+Object.defineProperty(exports, "_rawStartBatch", { enumerable: true, get: function () { return alien_signals_1.startBatch; } });
+Object.defineProperty(exports, "_rawEndBatch", { enumerable: true, get: function () { return alien_signals_1.endBatch; } });
+Object.defineProperty(exports, "_rawGetCurrentSub", { enumerable: true, get: function () { return alien_signals_1.getCurrentSub; } });
+Object.defineProperty(exports, "_rawSetCurrentSub", { enumerable: true, get: function () { return alien_signals_1.setCurrentSub; } });
+Object.defineProperty(exports, "_rawEffect", { enumerable: true, get: function () { return alien_signals_1.effect; } });
+const alien_signals_2 = require("alien-signals");
+const contents_1 = require("./contents");
+/**
+ * Decorate a native signal function with helpers & identity.
+ */
+function tagSignal(fn) {
+    Object.defineProperty(fn, contents_1.ReactiveFlags.IS_SIGNAL, { value: true });
+    Object.defineProperty(fn, "value", {
+        get: () => fn(),
+        set: (v) => fn(v),
+    });
+    // Add peek to mirror old API (non-tracking read)
+    if (!fn.peek)
+        Object.defineProperty(fn, "peek", { value: () => fn() });
+    if (!fn.get)
+        Object.defineProperty(fn, "get", { value: () => fn() });
+    if (!fn.set)
+        Object.defineProperty(fn, "set", { value: (v) => fn(v) });
+    return fn;
+}
+/**
+ * Decorate a native computed function with ergonomic helpers & readonly value accessor.
+ */
+function tagComputed(fn) {
+    Object.defineProperty(fn, contents_1.ReactiveFlags.IS_SIGNAL, { value: true });
+    Object.defineProperty(fn, "value", { get: () => fn() });
+    if (!fn.peek)
+        Object.defineProperty(fn, "peek", { value: () => fn() });
+    if (!fn.get)
+        Object.defineProperty(fn, "get", { value: () => fn() });
+    return fn;
+}
+/**
+ * Create a new writable function-form signal enhanced with `.value`, `.peek()`, `.get()`, `.set()`.
+ *
+ * @example
+ * const count = signal(0);
+ * count();      // 0 (track)
+ * count(1);     // write
+ * count.value;  // 1 (track)
+ * count.peek(); // 1 (non-tracking)
+ */
+const signal = (v) => tagSignal((0, alien_signals_2.signal)(v));
+exports.signal = signal;
+/**
+ * Create a lazy computed (readonly) signal derived from other signals.
+ *
+ * Computed signals are automatically cached and only recompute when their tracked
+ * dependencies change. The getter function is evaluated lazily—if you never read
+ * the computed value, the computation never runs.
+ *
+ * The returned function can be called directly `computed()` or accessed via `.value`.
+ * Use `.peek()` for non-tracking reads (won't establish reactive dependency).
+ *
+ * @example
+ * const count = signal(5);
+ * const doubled = computed(() => count() * 2);
+ * doubled();       // 10 (establishes dependency, caches result)
+ * doubled.value;   // 10 (cached, same as calling it)
+ * doubled.peek();  // 10 (no dependency tracking)
+ * count(10);
+ * doubled();       // 20 (recomputed because count changed)
+ */
+const computed = (getter) => tagComputed((0, alien_signals_2.computed)(getter));
+exports.computed = computed;
+/** Runtime guard that an unknown value is one of our tagged signals/computeds. */
+const isSignal = (s) => typeof s === "function" && !!s && !!s[contents_1.ReactiveFlags.IS_SIGNAL];
+exports.isSignal = isSignal;
+/**
+ * Execute multiple signal writes in a single batched update frame.
+ * All downstream computed/effect re-evaluations are deferred until the function exits.
+ *
+ * IMPORTANT: The callback MUST be synchronous. If it returns a Promise the batch will
+ * still end immediately after scheduling, possibly causing mid-async flushes.
+ *
+ * @example
+ * batch(() => {
+ *   count(count() + 1);
+ *   other(other() + 2);
+ * }); // effects observing both run only once
+ */
+function batch(fn) {
+    (0, alien_signals_2.startBatch)();
+    try {
+        return fn();
+    }
+    finally {
+        (0, alien_signals_2.endBatch)();
+    }
+}

package/dist/deepSignal.d.ts

@@ -0,0 +1,26 @@
+import { DeepPatchJITSubscriber, DeepPatchSubscriber, DeepSignal, DeepSignalOptions } from "./types";
+/** Runtime guard that checks whether a value is a deepSignal proxy. */
+export declare function isDeepSignal(value: any): boolean;
+/**
+ * Create a deep reactive proxy for objects, arrays or Sets.
+ * Returns the input itself, if it's a deepSignal already.
+ * Throws if provided with unsupported input types.
+ */
+export declare function deepSignal<T extends object>(input: T, options?: DeepSignalOptions): DeepSignal<T>;
+/**
+ * Low-level function, you should probably use `watch` instead.
+ *
+ * Register a deep mutation subscriber for the provided root or proxy.
+ */
+export declare function subscribeDeepMutations(root: object | symbol, cb: DeepPatchSubscriber | DeepPatchJITSubscriber, triggerInstantly?: boolean): () => void;
+/** Return the root identifier symbol for a deepSignal proxy (if any). */
+export declare function getDeepSignalRootId(value: any): symbol | undefined;
+/** Retrieve the current patch version for a deepSignal root (if tracked). */
+export declare function getDeepSignalVersion(root: object | symbol): number | undefined;
+/** Mark an object so deepSignal skips proxying it (shallow boundary). */
+export declare function shallow<T extends object>(obj: T): T;
+/** Force a specific synthetic ID to be used for a Set entry prior to insertion. */
+export declare function setSetEntrySyntheticId(obj: object, id: string | number): void;
+/** Convenience helper to add an entry to a proxied Set with a pre-defined synthetic ID. */
+export declare function addWithId<T>(set: Set<T>, entry: T, id: string | number): T;
+//# sourceMappingURL=deepSignal.d.ts.map

package/dist/deepSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepSignal.d.ts","sourceRoot":"","sources":["../src/deepSignal.ts"],"names":[],"mappings":"AAWA,OAAO,EAGH,sBAAsB,EACtB,mBAAmB,EACnB,UAAU,EACV,iBAAiB,EAMpB,MAAM,SAAS,CAAC;AAi/BjB,uEAAuE;AACvE,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,iBAAiB,GAC5B,UAAU,CAAC,CAAC,CAAC,CAwBf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAClC,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,EAAE,EAAE,mBAAmB,GAAG,sBAAsB,EAChD,gBAAgB,GAAE,OAAe,GAClC,MAAM,IAAI,CAoBZ;AAED,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAChC,IAAI,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,GAAG,SAAS,CAIpB;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAGnD;AAED,mFAAmF;AACnF,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,QAGtE;AAED,2FAA2F;AAC3F,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAa1E"}