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

package/dist/types-cjs/store/store.d.cts

@@ -1,4 +1,5 @@
 import { STORE_SNAPSHOT_PROPS, type Computed, type Refreshable, type Signal } from "../core/index.cjs";
+import { type Transition } from "../core/scheduler.cjs";
 /** A read-only view of a store's value as seen by consumers. Mutate it via the paired `StoreSetter`. */
 export type Store<T> = Readonly<T>;
 /**
@@ -17,6 +18,10 @@ export type Store<T> = Readonly<T>;
  * whose derive function reconciles its return by `options.key`.
  */
 export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
+/** Tuple returned by the plain `createStore(initialValue)` form. */
+export type StoreReturn<T> = [get: Store<T>, set: StoreSetter<T>];
+/** Tuple returned by the derived `createStore(fn, seed, options?)` form. */
+export type ProjectionStoreReturn<T> = [get: Refreshable<Store<T>>, set: StoreSetter<T>];
 /** Base options for store primitives. */
 export interface StoreOptions {
     /** Debug name (dev mode only) */
@@ -24,26 +29,53 @@ export interface StoreOptions {
 }
 /** Options for derived/projected stores created with `createStore(fn)`, `createProjection`, or `createOptimisticStore(fn)`. */
 export interface ProjectionOptions extends StoreOptions {
-    /** Key property name or function for reconciliation identity */
-    key?: string | ((item: NonNullable<any>) => any);
+    /** Key property name or function for reconciliation identity; `null` merges positionally */
+    key?: string | ((item: NonNullable<any>) => any) | null;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
+    /**
+     * Treat the seed as commit #0: the store is born committed with the seed's
+     * contents, shown until the derive's first real answer lands. While that
+     * first answer is in flight, reads serve the seed everywhere — nothing
+     * suspends to a `<Loading>` boundary, no transition is held, and
+     * `isPending` stays false (the seed answers by declaration; first-load
+     * affordances belong to the data, e.g. a `skeleton: true` field in the
+     * seed). Once the first answer lands (reconciled into the seed), refetches
+     * use normal pending semantics with `isPending` true.
+     *
+     * The store equivalent of `MemoOptions.loadingValue`; the seed already
+     * carries the placeholder shape, so this is just the opt-in.
+     */
+    seedLoadingValue?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
-export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
-export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
+/**
+ * Brand symbols used internally by the store proxy / projection plumbing.
+ * Cross-package wiring; not part of the user-facing API.
+ *
+ * @internal
+ */
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol, $AFFECTS: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 export type StoreNode = {
     [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
     [STORE_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OWNERS]?: Record<PropertyKey, Transition | null>;
     [STORE_NODE]?: DataNodes;
     [STORE_HAS]?: DataNodes;
+    [STORE_CUSTOM_PROTO]?: boolean;
     [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
     [STORE_LOOKUP]?: WeakMap<any, any>;
     [STORE_FIREWALL]?: Computed<any>;
     [STORE_OPTIMISTIC]?: boolean;
     [STORE_SNAPSHOT_PROPS]?: Record<PropertyKey, any>;
+    [STORE_PARENT]?: StoreNode;
+    [STORE_SHALLOW]?: boolean;
+    [STORE_DESC]?: boolean;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
@@ -52,11 +84,72 @@ export declare namespace SolidStore {
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
 export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: (target: StoreNode) => void): any;
 export declare const storeLookup: WeakMap<WeakKey, any>;
+export declare const symbolKeyedRecords: WeakSet<object>;
+export declare function lookupTarget(value: any, lookup?: WeakMap<any, any>): StoreNode | undefined;
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+export declare let rawValuesUsed: boolean;
+export declare function isRawValue(value: any): boolean;
+export declare function markRaw<T>(value: T): T;
+export declare function markRawIngest(container: any): void;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function wrapShallow<T extends Record<PropertyKey, any>>(value: T): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
+/**
+ * Single chokepoint for the store's layered value resolution: returns the
+ * override layer (optimistic first, then regular) that shadows `property`, or
+ * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
+ * resolve through this — hand-inlining the layer order is how the optimistic
+ * layer gets missed (#2850).
+ */
+export declare function getOverlayLayer(target: StoreNode, property: PropertyKey): Record<PropertyKey, any> | undefined;
+/**
+ * The value a store leaf's backing signal currently shows to readers: active
+ * override, else held pending value, else committed value.
+ */
+export declare function visibleNodeValue(node: DataNode): any;
+/**
+ * Witness live mark coverage of a record into the active isPending() probe.
+ * Tracked reads don't need this — they go through real signal nodes, which
+ * carry marks directly (declaration walk or birth inheritance). This covers
+ * UNTRACKED probes reading through records whose nodes never materialized
+ * (no observer ever subscribed, so no node exists to carry the mark).
+ * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
+ *
+ * @internal
+ */
+export declare function witnessAffectsMark(target: StoreNode, property?: PropertyKey): void;
+/**
+ * Resolves the store nodes an `affects()` declaration marks: with a `key`,
+ * the named slot's leaf node (upserted so the mark has an addressable
+ * carrier); without, the record's $AFFECTS carrier plus every LIVE node in
+ * its subtree (the edges existing readers subscribed through), with the
+ * subtree's identities snapshotted into the mark's scope so nodes created
+ * during the window — and untracked probes over captured proxies — resolve
+ * against it (#2882).
+ *
+ * @internal
+ */
+export declare function getStoreAffectsNodes(target: StoreNode, key?: PropertyKey): DataNode[];
 export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
+export declare function notifySelf(target: StoreNode): void;
+/**
+ * The write overlay a walk must read through: optimistic writes shadow
+ * regular pending writes, the same resolution order as every proxy trap and
+ * `reconcile` (#2850). Merging allocates only in the rare both-present case
+ * (a derived optimistic store with an in-flight projection commit).
+ */
+export declare function mergedOverlay(target: StoreNode): Record<PropertyKey, any> | undefined;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+export declare function getStoreKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): PropertyKey[];
+export declare function getStoreSymbols(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined): symbol[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
 export declare const storeTraps: ProxyHandler<StoreNode>;
 export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
@@ -113,6 +206,8 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  *
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
-export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Refreshable<Store<T>>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>, options?: StoreOptions & {
+    shallow?: boolean;
+}): StoreReturn<T>;
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): ProjectionStoreReturn<T>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0-rc.0",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -14,7 +14,9 @@
     "access": "public"
   },
   "main": "./dist/node.cjs",
-  "module": "./dist/prod.js",
+  "module": "./dist/prod/index.js",
+  "unpkg": "./dist/prod/index.js",
+  "jsdelivr": "./dist/prod/index.js",
   "types": "./dist/types/index.d.ts",
   "type": "module",
   "sideEffects": false,
@@ -28,7 +30,7 @@
         "types": "./dist/types/index.d.ts",
         "test": "./dist/dev.js",
         "development": "./dist/dev.js",
-        "default": "./dist/prod.js"
+        "default": "./dist/prod/index.js"
       },
       "require": {
         "types": "./dist/types-cjs/index.d.cts",
@@ -40,21 +42,21 @@
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
     "@rollup/plugin-replace": "^6.0.3",
-    "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/node": "^25.0.8",
     "rimraf": "^5.0.1",
     "rollup": "^4.53.4",
     "rollup-plugin-prettier": "^4.1.2",
+    "terser": "^5.49.0",
     "tslib": "^2.8.1",
-    "typescript": "5.9.3",
-    "vite": "^5.4.10",
-    "vitest": "^2.0.0"
+    "typescript": "^6.0.3",
+    "vite": "^7.0.0",
+    "vitest": "^4.1.6"
   },
   "scripts": {
     "build": "npm-run-all -nl build:* && pnpm types",
-    "build:clean": "rimraf dist/dev.js dist/prod.js dist/node.cjs",
-    "build:js": "rollup -c",
+    "build:clean": "rimraf dist/dev dist/prod dist/node dist/dev.js dist/prod.js dist/node.cjs",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/node.cjs && node ./scripts/check-pure.mjs dist/prod",
     "types": "tsc -p tsconfig.build.json && node ../../scripts/sync-dual-types.mjs ./dist/types ./dist/types-cjs",
     "test": "vitest run",
     "test:watch": "vitest watch tests",