@solidjs/signals 0.13.13 → 2.0.0-beta.8

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

@@ -0,0 +1,19 @@
+import { $REFRESH } from "../core/index.cjs";
+import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from "./store.cjs";
+/**
+ * Creates an optimistic store that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ *
+ * When called with a plain value, creates an optimistic store.
+ * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key).
+ *
+ * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
+ * @param store The plain store value, or the backing seed when using the derived-store form.
+ * @param options Optional projection options for reconciliation.
+ *
+ * @returns A tuple containing a store accessor and a setter function to apply changes.
+ */
+export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+    [$REFRESH]: any;
+}, set: StoreSetter<T>];

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

@@ -0,0 +1,40 @@
+import { $REFRESH, type Computed } from "../core/index.cjs";
+import { type ProjectionOptions, type Store } from "./store.cjs";
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
+    store: Store<T> & {
+        [$REFRESH]: any;
+    };
+    node: Computed<void | T>;
+};
+/**
+ * Creates a mutable derived store (projection). The derive function receives a mutable
+ * draft and can mutate it directly or return a new value for reconciliation.
+ *
+ * ```typescript
+ * const store = createProjection<T>(fn, seed, options?: ProjectionOptions);
+ * ```
+ * @param fn a function that receives the current draft and mutates it or returns new data
+ * @param seed the backing store host value to wrap and reconcile into
+ * @param options `ProjectionOptions` -- name, key
+ *
+ * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
+ */
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
+    [$REFRESH]: any;
+};
+/**
+ * Shared projection computed body used by both `createProjection` and the derived
+ * form of `createOptimisticStore`. Encapsulates the write-trap draft, `storeSetter`
+ * wrapping, the `handleAsync` subscription with a setter callback, and the commit
+ * path (which must always go through `storeSetter` so the `writeOnly` guard is
+ * engaged during `reconcile`'s property reads).
+ *
+ * `wrapCommit` is invoked for every commit (sync return and each async yield) and
+ * lets callers layer extra context around the write — e.g. the optimistic store
+ * re-enters `setProjectionWriteActive` so reconciles target `STORE_OVERRIDE`
+ * instead of `STORE_OPTIMISTIC_OVERRIDE` even when an async yield fires outside
+ * the outer `setProjectionWriteActive` scope.
+ */
+export declare function runProjectionComputed<T extends object>(wrappedStore: Store<T>, fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, key: string | ((item: NonNullable<any>) => any), wrapCommit?: (write: () => void) => void): Computed<void | T>;
+export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;
+export declare const writeTraps: ProxyHandler<any>;

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

@@ -0,0 +1 @@
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;

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

@@ -0,0 +1,68 @@
+import { $REFRESH, STORE_SNAPSHOT_PROPS, type Computed, type Signal } from "../core/index.cjs";
+export type Store<T> = Readonly<T>;
+export type StoreSetter<T> = (fn: (state: T) => T | void) => void;
+/** Base options for store primitives. */
+export interface StoreOptions {
+    /** Debug name (dev mode only) */
+    name?: string;
+}
+/** 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);
+}
+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";
+export type StoreNode = {
+    [$PROXY]: any;
+    [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_OPTIMISTIC_OVERRIDE]?: Record<PropertyKey, any>;
+    [STORE_NODE]?: DataNodes;
+    [STORE_HAS]?: DataNodes;
+    [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>;
+};
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+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 function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function setWriteOverride(value: boolean): void;
+export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
+export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
+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;
+/**
+ * Creates a deeply reactive store with proxy-based tracking.
+ *
+ * When called with a plain value, wraps it in a reactive proxy.
+ * When called with a function, creates a derived projection store with `ProjectionOptions` (name, key).
+ *
+ * ```typescript
+ * // Plain store
+ * const [store, setStore] = createStore<T>(initialValue);
+ * // Derived store (projection)
+ * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
+ * ```
+ * @param store initial value to wrap in a reactive proxy, or a derive function
+ * @param options `ProjectionOptions` -- name, key (only for derived stores)
+ *
+ * @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: Store<T> & {
+    [$REFRESH]: any;
+}, set: StoreSetter<T>];
+export {};

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

@@ -0,0 +1,30 @@
+import { type NotWrappable } from "./store.cjs";
+type W<T> = Exclude<T, NotWrappable>;
+type KeyOf<T> = number extends keyof T ? 0 extends 1 & T ? keyof T : [T] extends [never] ? never : [T] extends [readonly unknown[]] ? number : keyof T : keyof T;
+export type CustomPartial<T> = T extends readonly unknown[] ? "0" extends keyof T ? {
+    [K in Extract<keyof T, `${number}`>]?: T[K];
+} : {
+    [x: number]: T[number];
+} : Partial<T>;
+export type StorePathRange = {
+    from?: number;
+    to?: number;
+    by?: number;
+};
+export type ArrayFilterFn<T> = (item: T, index: number) => boolean;
+export type PathSetter<T> = T | CustomPartial<T> | ((prev: T) => T | CustomPartial<T>) | typeof DELETE;
+export type Part<T, K extends KeyOf<T> = KeyOf<T>> = K | ([K] extends [never] ? never : readonly K[]) | ([T] extends [readonly unknown[]] ? ArrayFilterFn<T[number]> | StorePathRange : never);
+declare const DELETE: unique symbol;
+export interface storePath {
+    DELETE: typeof DELETE;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>, K7 extends KeyOf<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, k7: Part<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>, K7>, setter: PathSetter<W<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>[K7]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>, K6 extends KeyOf<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, k6: Part<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>, K6>, setter: PathSetter<W<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>[K6]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>, K5 extends KeyOf<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, k5: Part<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>, K5>, setter: PathSetter<W<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>[K5]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>, K4 extends KeyOf<W<W<W<W<T>[K1]>[K2]>[K3]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, k4: Part<W<W<W<W<T>[K1]>[K2]>[K3]>, K4>, setter: PathSetter<W<W<W<W<T>[K1]>[K2]>[K3]>[K4]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>, K3 extends KeyOf<W<W<W<T>[K1]>[K2]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, k3: Part<W<W<W<T>[K1]>[K2]>, K3>, setter: PathSetter<W<W<W<T>[K1]>[K2]>[K3]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>, K2 extends KeyOf<W<W<T>[K1]>>>(k1: Part<W<T>, K1>, k2: Part<W<W<T>[K1]>, K2>, setter: PathSetter<W<W<T>[K1]>[K2]>): (state: T) => void;
+    <T, K1 extends KeyOf<W<T>>>(k1: Part<W<T>, K1>, setter: PathSetter<W<T>[K1]>): (state: T) => void;
+    <T>(setter: PathSetter<T>): (state: T) => void;
+}
+export declare const storePath: storePath;
+export {};

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

@@ -0,0 +1,43 @@
+/**
+ * Returns a non reactive copy of the store object.
+ * It will attempt to preserver the original reference unless the value has been modified.
+ * @param item store proxy object
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+/**
+ * Returns a non-reactive snapshot of the store while subscribing to all nested changes.
+ * Subscribes to `$TRACK` at every level so that any deep change triggers recomputation,
+ * and returns plain (non-proxy) data. Works correctly with `reconcile()`.
+ * @param store store proxy object
+ */
+export declare function deep<T extends object>(store: T): T;
+type DistributeOverride<T, F> = T extends undefined ? F : T;
+type Override<T, U> = T extends any ? U extends any ? {
+    [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];
+} & {
+    [K in keyof U]: K extends keyof T ? DistributeOverride<U[K], T[K]> : U[K];
+} : T & U : T & U;
+type OverrideSpread<T, U> = T extends any ? {
+    [K in keyof ({
+        [K in keyof T]: any;
+    } & {
+        [K in keyof U]?: any;
+    } & {
+        [K in U extends any ? keyof U : keyof U]?: any;
+    })]: K extends keyof T ? Exclude<U extends any ? U[K & keyof U] : never, undefined> | T[K] : U extends any ? U[K & keyof U] : never;
+} : T & U;
+type Simplify<T> = T extends any ? {
+    [K in keyof T]: T[K];
+} : T;
+type _Merge<T extends unknown[], Curr = {}> = T extends [
+    infer Next | (() => infer Next),
+    ...infer Rest
+] ? _Merge<Rest, Override<Curr, Next>> : T extends [...infer Rest, infer Next | (() => infer Next)] ? Override<_Merge<Rest, Curr>, Next> : T extends [] ? Curr : T extends (infer I | (() => infer I))[] ? OverrideSpread<Curr, I> : Curr;
+export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
+export declare function merge<T extends unknown[]>(...sources: T): Merge<T>;
+export type Omit<T, K extends readonly (keyof T)[]> = {
+    [P in keyof T as Exclude<P, K[number]>]: T[P];
+};
+export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export {};

package/package.json

@@ -1,23 +1,41 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.13.13",
-  "description": "SolidJS' standalone reactivity implementation",
+  "version": "2.0.0-beta.8",
+  "description": "SolidJS' reactive core implementation",
   "author": "Ryan Carniato",
   "license": "MIT",
+  "homepage": "https://solidjs.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/solidjs/signals"
+    "url": "https://github.com/solidjs/solid"
   },
-  "type": "module",
-  "main": "dist/node.cjs",
-  "module": "dist/prod.js",
-  "types": "dist/types/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
+  "main": "./dist/node.cjs",
+  "module": "./dist/prod.js",
+  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "package.json"
   ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "test": "./dist/dev.js",
+        "development": "./dist/dev.js",
+        "default": "./dist/prod.js"
+      },
+      "require": {
+        "types": "./dist/types-cjs/index.d.cts",
+        "default": "./dist/node.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
   "devDependencies": {
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
     "@rollup/plugin-replace": "^6.0.3",
@@ -32,27 +50,16 @@
     "vite": "^5.4.10",
     "vitest": "^2.0.0"
   },
-  "exports": {
-    ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": {
-        "test": "./dist/dev.js",
-        "development": "./dist/dev.js",
-        "default": "./dist/prod.js"
-      },
-      "require": "./dist/node.cjs"
-    }
-  },
   "scripts": {
-    "build": "rimraf dist && rollup -c && pnpm types",
-    "types": "tsc -p tsconfig.build.json",
-    "format": "prettier src tests --write --log-level warn",
-    "sandbox": "node ./.sandbox/launch.js",
+    "build": "npm-run-all -nl build:* && pnpm types",
+    "build:clean": "rimraf dist/dev.js dist/prod.js dist/node.cjs",
+    "build:js": "rollup -c",
+    "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",
     "test:gc": "node --expose-gc ./vitest.js",
     "test:gc:watch": "node --expose-gc ./vitest.js --watch",
-    "test:coverage": "vitest run --coverage",
+    "coverage": "vitest run --coverage",
     "bench": "vitest bench --run"
   }
 }