@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/types/store/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Store — public types, brand symbols, wrappability and raw marking. Shared
+ * by every store module; carries no reactive machinery of its own.
+ */
+import type { Refreshable } from "../core/index.js";
+/** A reactive view of a store's value. Update it through the paired `StoreSetter`. */
+export type Store<T> = T;
+/**
+ * A store setter. The callback receives a writable **draft** of the store.
+ *
+ * - **Mutate in place (canonical):** `s.foo = 1`, `s.list.push(x)`,
+ *   `s.list.splice(i, 1)`. This is the default form for most updates.
+ * - **Return a new value:** for shapes where mutation is awkward, most
+ *   commonly removing items (`s => s.list.filter(...)`). Arrays are replaced
+ *   by index (length adjusted); objects are shallow-diffed at the top level
+ *   (keys present in the returned value are written, missing keys deleted).
+ *
+ * The setter does **not** perform keyed reconciliation. If you need surviving
+ * items to keep their store identity across full-array replacement, use the
+ * projection form — `createStore(fn, seed, { key })` or
+ * `createProjection(fn, seed, { key })` — 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, options?)` 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>];
+/** Options shared by all store primitives. */
+export interface StoreOptions {
+    /**
+     * Debug name (dev and observe builds). Property nodes are labelled
+     * `<name>.<key>` in attribution output (`todos.title`); a derived store's
+     * projection node carries the name itself.
+     */
+    name?: string;
+    /**
+     * Source location (`file:line:col`, root-relative) written by the
+     * compiler's `sourceNames` `locations` kind; dev and observe builds keep it
+     * for console reports and diagnostic events, production ignores it. Not
+     * meant to be written by hand.
+     */
+    loc?: string;
+    /** Single-layer store: root keys reactive, values raw records replaced by reference */
+    shallow?: boolean;
+}
+/**
+ * Options for derived/projected stores created with
+ * `createStore(fn, seed, options?)`, `createProjection(fn, seed, options?)`,
+ * or `createOptimisticStore(fn, seed, options?)`.
+ */
+export interface ProjectionOptions extends StoreOptions {
+    /** Key property name or function for reconciliation identity; `null` merges positionally */
+    key?: string | ((item: NonNullable<any>) => any) | null;
+    /**
+     * 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;
+}
+/** @internal */
+export type NoFn<T> = T extends Function ? never : T;
+/**
+ * Rejects array roots on the seedless derived form: a store's root shape is
+ * fixed when it is created, and `[]` is already a complete seed for an array.
+ * @internal
+ */
+export type NoArray<T> = Extract<T, readonly unknown[]> extends never ? unknown : never;
+/** Brand keys the proxy answers directly (never user data). */
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $RECORD: unique symbol;
+export declare namespace SolidStore {
+    interface Unwrappable {
+    }
+}
+export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
+export declare let rawValuesUsed: boolean;
+export declare function isRawValue(value: any): boolean;
+/** Mark a value so no store ever wraps it (sticky; it reads as a leaf). */
+export declare function markRaw<T>(value: T): T;
+/** A shallow store's ingested record: raw by contract (values served
+ * verbatim, slots replaced by reference). */
+export declare function markRawOne(v: any): void;
+export declare function markRawIngest(container: any): void;
+/** Plain objects and arrays wrap; class instances, DOM nodes, frozen objects
+ * and markRaw'd values are leaves. Per-prototype verdict cached. */
+export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
+export declare function ownEnumerableKeys(o: object): (string | symbol)[];
+export declare let writeOverride: boolean;
+export declare function setWriteOverride(value: boolean): void;
+/** The list driver's view of a shallow store (map.ts): the backing a read of
+ * every slot serves this reader, or `undefined` when the list is no shallow
+ * store or a slot read could differ from it. Installed by store.ts's top
+ * level, so a `<For>` in an app without stores carries none of it; it lives
+ * beside `$TRACK` so map.ts reaches no other store module. */
+export declare let shallowView: ((t: any) => any[] | undefined) | null;
+export declare function installShallowView(view: (t: any) => any[] | undefined): void;

package/dist/types/store/utils.d.ts

@@ -21,6 +21,173 @@ type _Merge<T extends unknown[], Curr = {}> = T extends [
     ...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>>;
+/** @internal What a source ENTRY is, decided once when the view is built
+ * (`merge()` learns it while flattening; `omit()` from its argument) and
+ * carried beside the entry — `MergeView.kinds[i]`, `OmitView.kind` — so no
+ * read has to ask. Asking is the cost: any brand check on a Proxy is a trap
+ * (`instanceof` is a `getPrototypeOf` trap, ~20 ns on a store — as much as
+ * the read itself), and a merge over a store did two per read. */
+export declare const SOURCE_PLAIN = 0;
+export declare const SOURCE_OMIT = 1;
+export declare const SOURCE_PROXY = 2;
+export declare const SOURCE_MEMO = 3;
+export declare const SOURCE_MERGE = 4;
+export type SourceKind = 0 | 1 | 2 | 3 | 4;
+/** @internal The record behind an `omit()` proxy: `source` with `hidden`
+ * keys removed. It is the proxy's TARGET, so the shared handler reads it as
+ * plain fields — no per-instance closures — and it is what props consumers
+ * walk directly (`merge`, `spread`, `ssrElement`): a view never materializes
+ * a copy, and a consumer that knows the record never goes through its traps
+ * (a `getOwnPropertyDescriptor` trap per key allocates a descriptor and a
+ * getter, so enumerating a proxy costs more than the copy it was avoiding).
+ * `hidden` is a key list or a predicate (`omit(props, k => k[0] === "$")`).
+ *
+ * An omit over a `merge()` holds the merge's RECORD (`MergeView`, kind
+ * `SOURCE_MERGE`) — never its proxy, so no read hops through a trap — and is
+ * one record however many leaves the merge has. A consumer walks it as ONE
+ * filtered entry (`sourceKeys` / `sourceGet` recurse into the merge's
+ * sources by function call), and a later `merge()` over it carries the
+ * record as one entry instead of copying its leaves: on a component chain of
+ * defaults + omit + spread (`merge(omit(merge(omit(props))))`) the layers
+ * nest as records, each a few fields, where a flatten to leaf views built a
+ * view and a combined key list per leaf per layer — the largest allocation
+ * of a Kobalte-shaped render. A merge leaf may be merge's memo for a
+ * function source; it is resolved on access. */
+export declare class OmitView {
+    source: any;
+    /** of `source` — PLAIN, PROXY (a store or a foreign proxy), MEMO, or
+     * MERGE (a `MergeView` record); never OMIT, a view over a view folds
+     * into one. */
+    kind: SourceKind;
+    hidden: Hidden;
+    /** see `MergeView.table` */
+    table: Map<PropertyKey, any> | null | number;
+    /** see `tableOwnKeys` / `tableDescriptor` */
+    keys: (string | symbol)[] | undefined;
+    descs: Map<PropertyKey, PropertyDescriptor> | undefined;
+    constructor(source: any, 
+    /** of `source` — PLAIN, PROXY (a store or a foreign proxy), MEMO, or
+     * MERGE (a `MergeView` record); never OMIT, a view over a view folds
+     * into one. */
+    kind: SourceKind, hidden: Hidden);
+}
+type Hidden = PropertyKey[] | ((key: PropertyKey) => boolean);
+/** @internal The `OmitView` behind an `omit()` proxy, or undefined. */
+export declare function omitView(o: any): OmitView | undefined;
+/** @internal Own string keys of a source entry — every consumer skips
+ * symbols itself. */
+export declare function sourceKeys(s: any, kind: SourceKind): (string | symbol)[];
+/** @internal `key in entry`. */
+export declare function sourceHas(s: any, kind: SourceKind, key: PropertyKey): boolean;
+/** @internal `entry[key]` — the source's getter runs once, here. */
+export declare function sourceGet(s: any, kind: SourceKind, key: PropertyKey): any;
+/** @internal Whether the own key set of a props object cannot change
+ * reactively: a plain object, or a merge/omit view over plain objects only.
+ * A consumer may then decide from `Object.getOwnPropertyDescriptor` once —
+ * "no `children` key" or "a data `children`" holds for the object's lifetime,
+ * so no tracking scope is needed for it (#3388). For a store, or a view with
+ * a store or memo leaf, keys can appear later and the reactive path is the
+ * only correct one. */
+export declare function hasStaticKeys(o: any): boolean;
+/**
+ * Whether `o[key]` can never change for the lifetime of `o`: the key is a
+ * data property of a plain object, or is absent from an object whose key set
+ * is fixed. A getter, a key on a store, a memo-backed `merge()` source, or
+ * any key of an object whose keys can appear later (a store) is not static.
+ *
+ * Looks through `merge()`/`omit()` views to the leaf that owns the key. Any
+ * object will do, but props are the case it exists for: the compiler encodes
+ * a literal at the call site (`as="button"`) as a data property and an
+ * expression (`as={isLink() ? "a" : "button"}`) as a getter, so a component
+ * library reads the caller's own static/dynamic classification of a prop at
+ * runtime — identically on server and client, the compiler emitting the same
+ * own DESCRIPTORS on both (the object behind them may differ: the server
+ * builds props as a plain-prototype instance with shared getters) — and can
+ * take a no-computation path for the literal:
+ *
+ * ```tsx
+ * const Tag = dynamic(() => props.as, { static: isStatic(props, "as") });
+ * ```
+ *
+ * One descriptor lookup; no read of the value, nothing tracked.
+ */
+export declare function isStatic(o: object, key: PropertyKey): boolean;
+/** @internal */
+export declare class MergeView {
+    sources: any[];
+    /** `kinds[i]` is what `sources[i]` is (see `SourceKind`). */
+    kinds: SourceKind[];
+    /** key → the plain leaf that owns it (later sources win), built by an
+     * enumeration or once the reads have paid for it (see `resolvedTable`)
+     * when every leaf has static keys; `null` when one doesn't. Until then
+     * the slot counts the per-key trap reads so far. One slot rather than a
+     * counter field of its own: a view is built per source per component
+     * layer, and each field initializer is a measurable share of a
+     * constructor that small in the lower JIT tiers. */
+    table: Map<PropertyKey, any> | null | number;
+    /** see `tableOwnKeys` / `tableDescriptor` */
+    keys: (string | symbol)[] | undefined;
+    descs: Map<PropertyKey, PropertyDescriptor> | undefined;
+    constructor(sources: any[], 
+    /** `kinds[i]` is what `sources[i]` is (see `SourceKind`). */
+    kinds: SourceKind[]);
+}
+/** @internal The `MergeView` behind a `merge()` proxy — its flattened
+ * `sources` with their `kinds` — or undefined. */
+export declare function mergeView(o: any): MergeView | undefined;
+/** @internal The record behind a merge() or omit() proxy — a `MergeView`
+ * (flattened `sources` with their `kinds`) or an `OmitView` — or undefined
+ * for anything else (a plain object, a store, a foreign proxy). Two fast
+ * traps on a proxy (`has`, then `$RECORD`), none on a plain object. */
+export declare function viewOf(o: any): MergeView | OmitView | undefined;
+/** @internal The resolved key table of a merge/omit view — every own key of
+ * the view mapped to the plain object that owns it, in merged order (a key
+ * at the position of the last source that carries it, see `tableSet`) — or
+ * undefined when it has none: a leaf is a store or a memo source, whose
+ * keys can change, or the object is not a view at all.
+ *
+ * This is the flat object the eager copy used to build, made lazily and
+ * without copying: one pass over the leaves' own keys, then every
+ * `get`/`has`/descriptor is one lookup plus one read of the owning leaf, and
+ * a consumer (`spread` rerunning its effect) walks the table instead of
+ * re-deriving shadowing from the leaves each time. Own keys only, as the
+ * copy's were: a plain source's key set is fixed once merged (keys added to
+ * it later are not seen — the copy didn't see them either).
+ *
+ * It is built by an ENUMERATION — the `ownKeys` trap, or a consumer asking
+ * for it here — or once per-key reads have paid for it (`READS_FOR_TABLE`),
+ * not on the first read. A per-key read has a direct answer (a walk of the
+ * sources, last to first, one `in` each) whose cost is the source count,
+ * while the table's is every key of every leaf, so the walk wins until a
+ * view has been read about as many times as it has keys. On the server it
+ * never is: a component reads its props a few times, the element enumerates
+ * them once through its own source walk, and the view is gone — building on
+ * first read there cost a component chain a table per layer (profiled on
+ * the Kobalte-shaped chain: a third of SSR time in the table code and its
+ * garbage). On the
+ * client a view read on every reactive rerun crosses the threshold in its
+ * first few updates and is one lookup per read from then on, as before.
+ * Once built — by a `spread`, `Object.keys`, `{...props}`, or the count —
+ * every trap uses it. */
+export declare function resolvedTable(o: any): Map<PropertyKey, any> | undefined;
+/** @internal Every own string key of a props SOURCE — a plain object, a
+ * store or foreign proxy, or a merge/omit view — appended to `keys` in
+ * merged order with the object that owns each at the same index of
+ * `owners`: a key already listed (by this source or an earlier one) moves
+ * to the end, so several sources collected in turn give the order and the
+ * winners a merge of them would. A consumer that reads each key once
+ * (`ssrElement`) then reads `owners[i][keys[i]]` — the owner's getter runs
+ * there, once — and asks nothing else of a view: no table, no `in` walk per
+ * key through the merge/omit layers, no key list per leaf. One pass,
+ * however deep the layers nest. Symbols are listed; the consumer skips
+ * them. */
+export declare function sourceOwners(s: any, keys: (string | symbol)[], owners: any[]): void;
+/** @internal The flattened sources behind a `merge()` proxy, or undefined.
+ * A merge's writes are no-ops, so its sources are the whole truth. A COPY of
+ * a merge (`{...merged}`, a descriptor copy) is a plain object that carries
+ * no sources — `ownKeys` never lists $RECORD — so what is on the copy is
+ * the truth there and every consumer reads it directly (#3384). */
+export declare function mergeSources(o: any): any[] | undefined;
 /**
  * Merges multiple props-like objects into a single proxy that *preserves
  * reactivity*. Reads are forwarded to the right-most source that defines the
@@ -29,9 +196,23 @@ export type Merge<T extends unknown[]> = Simplify<_Merge<T>>;
  * Function arguments are treated as memo-backed sources — useful for passing
  * derived defaults whose computation should track reactively.
  *
+ * The result is a live VIEW of its sources, never a copy: creating it costs
+ * nothing per key, every read goes to the source that owns the key (a getter
+ * runs there, a data property is read live), and writing to it is a no-op.
+ * A single non-function source is returned as is. To own a mutable object,
+ * copy it: `{ ...merged }` snapshots the current values.
+ *
  * Use this in component bodies to merge defaults / overrides without losing
  * Solid's per-property tracking.
  *
+ * Reading props, here and anywhere: a prop's getter is defined only for a
+ * read through its own object (`props.x`, `{ ...props }`, `Reflect.get`,
+ * these views). Forwarding its descriptor onto another object and reading it
+ * there is not supported — the compiler's server-side props keep their state
+ * on the instance, so the getter needs its object as receiver. A copy that
+ * must stay live defines its own getter that reads through the source, as
+ * the no-Proxy paths of merge() and omit() do.
+ *
  * @example
  * ```tsx
  * function Button(_props: { label: string; type?: string; disabled?: boolean }) {
@@ -52,6 +233,12 @@ export type Omit<T, K extends readonly (keyof T)[]> = {
  * Use it to forward "rest" props to a child element while pulling out the
  * keys your component handles itself — the equivalent of `splitProps(p, ["a","b"])[1]`.
  *
+ * The result is a live VIEW of `props`, not a copy: nothing is read or
+ * materialized until a key is used, and a spread (`{...rest}`) or a later
+ * `merge()` walks the underlying object directly. A predicate hides keys by
+ * rule instead of by name — `omit(props, k => k[0] === "$")` — without
+ * enumerating first.
+ *
  * @example
  * ```tsx
  * function Input(props: { label: string; value: string; onInput: (v: string) => void } & JSX.HTMLAttributes<HTMLInputElement>) {
@@ -71,4 +258,5 @@ export type Omit<T, K extends readonly (keyof T)[]> = {
  * ```
  */
 export declare function omit<T extends Record<any, any>, K extends readonly (keyof T)[]>(props: T, ...keys: K): Omit<T, K>;
+export declare function omit<T extends Record<any, any>>(props: T, hidden: (key: keyof T & (string | symbol)) => boolean): Partial<T>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.2",
+  "version": "2.0.0-rc.20",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -8,17 +8,20 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/solidjs/solid.git",
-    "directory": "packages/solid-signals"
+    "directory": "packages/signals"
   },
   "publishConfig": {
     "access": "public"
   },
-  "main": "./dist/node.cjs",
+  "main": "./dist/prod/index.js",
   "module": "./dist/prod/index.js",
   "unpkg": "./dist/prod/index.js",
   "jsdelivr": "./dist/prod/index.js",
   "types": "./dist/types/index.d.ts",
   "type": "module",
+  "engines": {
+    "node": ">=22.12.0"
+  },
   "sideEffects": false,
   "files": [
     "dist",
@@ -26,19 +29,33 @@
   ],
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/types/index.d.ts",
-        "test": "./dist/dev.js",
-        "development": "./dist/dev.js",
-        "default": "./dist/prod/index.js"
-      },
-      "require": {
-        "types": "./dist/types-cjs/index.d.cts",
-        "default": "./dist/node.cjs"
-      }
+      "types": "./dist/types/index.d.ts",
+      "test": "./dist/dev.js",
+      "development": "./dist/dev.js",
+      "observe": "./dist/observe/index.js",
+      "default": "./dist/prod/index.js"
+    },
+    "./attribution": {
+      "types": "./dist/types/attribution.d.ts",
+      "test": "./dist/dev.attribution.js",
+      "development": "./dist/dev.attribution.js",
+      "observe": "./dist/observe/attribution.js",
+      "default": "./dist/prod/attribution.js"
     },
     "./package.json": "./package.json"
   },
+  "scripts": {
+    "build": "npm-run-all -nl build:* && pnpm types",
+    "build:clean": "rimraf dist/dev dist/prod dist/observe dist/*.js",
+    "build:js": "rollup -c && node ./scripts/mangle-props.mjs dist/prod dist/observe && node ./scripts/check-pure.mjs dist/prod && node ./scripts/check-pure.mjs dist/observe",
+    "types": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest watch tests",
+    "test:gc": "node --expose-gc ./vitest.js",
+    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
+    "coverage": "vitest run --coverage",
+    "bench": "vitest bench --run"
+  },
   "devDependencies": {
     "@codspeed/vitest-plugin": "^5.4.0",
     "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
@@ -53,17 +70,5 @@
     "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 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",
-    "test:gc": "node --expose-gc ./vitest.js",
-    "test:gc:watch": "node --expose-gc ./vitest.js --watch",
-    "coverage": "vitest run --coverage",
-    "bench": "vitest bench --run"
   }
-}
+}