@solidjs/signals 2.0.0-beta.9 → 2.0.0-rc.1

package/dist/prod/core/constants.js

@@ -0,0 +1,92 @@
+const REACTIVE_NONE = 0;
+
+const REACTIVE_CHECK = 1 << 0;
+
+const REACTIVE_DIRTY = 1 << 1;
+
+const REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+
+const REACTIVE_IN_HEAP = 1 << 3;
+
+const REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+
+const REACTIVE_ZOMBIE = 1 << 5;
+
+const REACTIVE_DISPOSED = 1 << 6;
+
+const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+
+const REACTIVE_SNAPSHOT_STALE = 1 << 8;
+
+const REACTIVE_LAZY = 1 << 9;
+
+const REACTIVE_MANUAL_WRITE = 1 << 10;
+
+/**
+ * The pending recompute is a re-ask of the same question: `refresh()` dirtied
+ * the node while no tracked input changed value. Cleared whenever a real
+ * value-change notification arrives (`insertSubs`), and consumed by
+ * `recompute` into the node's `_reask` classification — a quiet (re-ask)
+ * pending window does not read as pending (question-scoped pending model).
+ */ const REACTIVE_REASK = 1 << 11;
+
+// Static configuration bits packed into Owner/Computed/Signal _config.
+const CONFIG_OWNED_WRITE = 1 << 0;
+
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+
+const CONFIG_TRANSPARENT = 1 << 2;
+
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+
+const CONFIG_AUTO_DISPOSE = 1 << 5;
+
+const CONFIG_SYNC = 1 << 6;
+
+const STATUS_PENDING = 1 << 0;
+
+const STATUS_ERROR = 1 << 1;
+
+const STATUS_UNINITIALIZED = 1 << 2;
+
+const EFFECT_RENDER = 1;
+
+const EFFECT_USER = 2;
+
+const EFFECT_TRACKED = 3;
+
+const NOT_PENDING = {};
+
+const NO_SNAPSHOT = {};
+
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */ const OVERRIDE_UNDEFINED = {};
+
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */ function unwrapOverride(E) {
+    return E === OVERRIDE_UNDEFINED ? undefined : E;
+}
+
+const STORE_SNAPSHOT_PROPS = "sp";
+
+const SUPPORTS_PROXY = typeof Proxy === "function";
+
+const defaultContext = {};
+
+/**
+ * Brand symbol used by `Refreshable<T>` values (projection stores, async
+ * memos) to expose their underlying computation to `refresh()`. Not part of
+ * the user-facing API.
+ *
+ * @internal
+ */ const $REFRESH = Symbol("refresh");
+
+export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };

package/dist/prod/core/context.js

@@ -0,0 +1,67 @@
+import { NoOwnerError, ContextNotFoundError } from "./error.js";
+
+import { getOwner } from "./owner.js";
+
+/**
+ * Context provides a form of dependency injection. It is used to save from needing to pass
+ * data as props through intermediate components. This function creates a new context object
+ * that can be used with `getContext` and `setContext`.
+ *
+ * A default value can be provided here which will be used when a specific value is not provided
+ * via a `setContext` call.
+ */ function createContext(e, t) {
+    return {
+        id: Symbol(t),
+        defaultValue: e
+    };
+}
+
+/**
+ * Low-level owner-targeted context read. The user-facing read API is
+ * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
+ * cross-package wiring (e.g. hydration-aware context plumbing).
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ *
+ * @internal
+ */ function getContext(e, t = getOwner()) {
+    if (!t) {
+        throw new NoOwnerError;
+    }
+    const n = hasContext(e, t) ? t.we[e.id] : e.defaultValue;
+    if (isUndefined(n)) {
+        throw new ContextNotFoundError;
+    }
+    return n;
+}
+
+/**
+ * Low-level owner-targeted context write. The user-facing API is
+ * `createContext` (in `solid-js`); its provider component wraps this
+ * primitive. Exposed here for cross-package wiring.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ *
+ * @internal
+ */ function setContext(e, t, n = getOwner()) {
+    if (!n) {
+        throw new NoOwnerError;
+    }
+    // We're creating a new object to avoid child context values being exposed to parent owners. If
+    // we don't do this, everything will be a singleton and all hell will break lose.
+        n.we = {
+        ...n.we,
+        [e.id]: isUndefined(t) ? e.defaultValue : t
+    };
+}
+
+function hasContext(e, t) {
+    return !isUndefined(t?.we[e.id]);
+}
+
+function isUndefined(e) {
+    return typeof e === "undefined";
+}
+
+export { createContext, getContext, setContext };