├── .gitignore
├── .prettierrc.cjs
├── .sandbox
├── favicon-32x32.png
├── index.html
├── launch.js
└── main.ts
├── LICENSE
├── README.md
├── package.json
├── pnpm-lock.yaml
├── src
├── boundaries.ts
├── core
│ ├── constants.ts
│ ├── core.ts
│ ├── effect.ts
│ ├── error.ts
│ ├── flags.ts
│ ├── index.ts
│ ├── owner.ts
│ └── scheduler.ts
├── globals.d.ts
├── index.ts
├── map.ts
├── signals.ts
└── store
│ ├── index.ts
│ ├── projection.ts
│ ├── reconcile.ts
│ ├── store.ts
│ └── utils.ts
├── tests
├── context.test.ts
├── createAsync.test.ts
├── createEffect.test.ts
├── createErrorBoundary.test.ts
├── createMemo.test.ts
├── createRoot.test.ts
├── createSignal.test.ts
├── flushSync.test.ts
├── gc.test.ts
├── getOwner.test.ts
├── graph.test.ts
├── mapArray.test.ts
├── onCleanup.test.ts
├── repeat.test.ts
├── runWithObserver.test.ts
├── runWithOwner.test.ts
├── store
│ ├── createProjection.test.ts
│ ├── createStore.test.ts
│ ├── reconcile.test.ts
│ ├── recursive-effects.test.ts
│ ├── shared-clone.ts
│ ├── utilities.bench.ts
│ └── utilities.test.ts
└── untrack.test.ts
├── tsconfig.build.json
├── tsconfig.json
├── tsup.config.ts
├── vite.config.ts
└── vitest.js
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | dist/
3 | types/
4 | sandbox/
5 | .DS_STORE
--------------------------------------------------------------------------------
/.prettierrc.cjs:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | singleQuote: false,
3 | semi: true,
4 | arrowParens: 'avoid',
5 | trailingComma: 'none',
6 | printWidth: 100,
7 | tabWidth: 2,
8 | plugins: [require.resolve('@ianvs/prettier-plugin-sort-imports')],
9 | };
10 |
--------------------------------------------------------------------------------
/.sandbox/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/solidjs/signals/f464453012fd19997b757a9c000674f2ed0cd791/.sandbox/favicon-32x32.png
--------------------------------------------------------------------------------
/.sandbox/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 | X-Reactivity Sandbox
4 |
5 |
6 |
7 |
8 |
14 |
15 |
16 |
17 |
18 |
19 | X-Reactivity Sandbox
20 |
21 | Play with X-Reactivity in your browser, see the
22 | `sandbox`
23 | directory. None of your changes will be commited (git-ignored folder).
24 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/.sandbox/launch.js:
--------------------------------------------------------------------------------
1 | import { execSync } from "child_process";
2 | import fs from "fs";
3 | import path from "path";
4 |
5 | const SANDBOX_TEMPLATE = path.resolve(process.cwd(), ".sandbox"),
6 | SANDBOX_DIR = path.resolve(process.cwd(), "sandbox"),
7 | IGNORED_FILES = new Set(["launch.js"]);
8 |
9 | // Copy files from .sandbox template directory to sandbox.
10 | if (!fs.existsSync(SANDBOX_DIR)) {
11 | fs.mkdirSync(SANDBOX_DIR);
12 | const files = fs.readdirSync(SANDBOX_TEMPLATE);
13 | for (const file of files) {
14 | if (IGNORED_FILES.has(file)) continue;
15 | const from = path.resolve(SANDBOX_TEMPLATE, file);
16 | const to = path.resolve(SANDBOX_DIR, file);
17 | fs.writeFileSync(to, fs.readFileSync(from, "utf-8"));
18 | }
19 | }
20 |
21 | execSync("vite --open=/sandbox/index.html --port=3100 --host", {
22 | stdio: "inherit",
23 | });
24 |
--------------------------------------------------------------------------------
/.sandbox/main.ts:
--------------------------------------------------------------------------------
1 | import { createSignal, createMemo, createEffect } from "../src";
2 |
3 | // ...
4 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2023-2025 Ryan Carniato
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # @solidjs/signals
2 |
3 | Standalone Reactive implementation to serve as the basis of future (post 1.x) versions of SolidJS. This package aims to be core for Signals library made with rendering in mind so it may have more features and opinions than common Signals libraries, but are still necessary core to accomplish the type of capabilities we intend.
4 |
5 | This is not ready for production and should be considered pre-alpha. This package is completely experimental and every release may be breaking. It is also not tuned for performance as of yet as we are still focusing on capability.
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "@solidjs/signals",
3 | "version": "0.3.2",
4 | "description": "",
5 | "author": "Ryan Carniato",
6 | "license": "MIT",
7 | "repository": {
8 | "type": "git",
9 | "url": "https://github.com/solidjs/signals"
10 | },
11 | "type": "module",
12 | "main": "dist/node.cjs",
13 | "module": "dist/prod.js",
14 | "types": "dist/types/index.d.ts",
15 | "publishConfig": {
16 | "access": "public"
17 | },
18 | "files": [
19 | "dist"
20 | ],
21 | "scripts": {
22 | "build": "rimraf dist && tsup && pnpm types",
23 | "types": "tsc -p tsconfig.build.json",
24 | "format": "prettier src tests --write --log-level warn",
25 | "sandbox": "node ./.sandbox/launch.js",
26 | "test": "vitest run",
27 | "test:watch": "vitest watch tests",
28 | "test:gc": "node --expose-gc ./vitest.js",
29 | "test:gc:watch": "node --expose-gc ./vitest.js --watch",
30 | "test:coverage": "vitest run --coverage",
31 | "bench": "vitest bench --run"
32 | },
33 | "devDependencies": {
34 | "@ianvs/prettier-plugin-sort-imports": "^4.1.1",
35 | "@types/node": "^20.5.1",
36 | "rimraf": "^5.0.1",
37 | "tsup": "^7.2.0",
38 | "typescript": "5.1.6",
39 | "vite": "^5.4.10",
40 | "vitest": "^2.0.0"
41 | },
42 | "exports": {
43 | ".": {
44 | "types": "./dist/types/index.d.ts",
45 | "import": {
46 | "test": "./dist/dev.js",
47 | "development": "./dist/dev.js",
48 | "default": "./dist/prod.js"
49 | },
50 | "require": "./dist/node.cjs"
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/src/boundaries.ts:
--------------------------------------------------------------------------------
1 | import {
2 | Computation,
3 | compute,
4 | EagerComputation,
5 | ERROR_BIT,
6 | incrementClock,
7 | LOADING_BIT,
8 | NotReadyError,
9 | onCleanup,
10 | Owner,
11 | Queue,
12 | STATE_DIRTY,
13 | UNCHANGED,
14 | UNINITIALIZED_BIT
15 | } from "./core/index.js";
16 | import type { Effect, IQueue } from "./core/index.js";
17 |
18 | class BoundaryComputation extends EagerComputation {
19 | _propagationMask: number;
20 | constructor(compute: () => T, propagationMask: number) {
21 | super(undefined as any, compute, { defer: true });
22 | this._propagationMask = propagationMask;
23 | }
24 | write(value: T | UNCHANGED, flags: number) {
25 | super.write(value, flags & ~this._propagationMask);
26 | if (this._propagationMask & LOADING_BIT && !(this._stateFlags & UNINITIALIZED_BIT)) {
27 | flags &= ~LOADING_BIT;
28 | }
29 | this._queue.notify(this as any, this._propagationMask, flags);
30 | return this._value;
31 | }
32 | }
33 |
34 | function createBoundChildren(
35 | owner: Owner,
36 | fn: () => T,
37 | queue: IQueue,
38 | mask: number
39 | ): Computation {
40 | const parentQueue = owner._queue;
41 | parentQueue.addChild((owner._queue = queue));
42 | onCleanup(() => parentQueue.removeChild(owner._queue!));
43 | return compute(
44 | owner,
45 | () => {
46 | const c = new Computation(undefined, fn);
47 | return new BoundaryComputation(() => flatten(c.wait()), mask);
48 | },
49 | null
50 | );
51 | }
52 |
53 | class ConditionalQueue extends Queue {
54 | _disabled: Computation;
55 | _errorNodes: Set = new Set();
56 | _pendingNodes: Set = new Set();
57 | constructor(disabled: Computation) {
58 | super();
59 | this._disabled = disabled;
60 | }
61 | run(type: number) {
62 | if (!type || this._disabled.read()) return;
63 | return super.run(type);
64 | }
65 | notify(node: Effect, type: number, flags: number) {
66 | if (this._disabled.read()) {
67 | if (type & LOADING_BIT) {
68 | if (flags & LOADING_BIT) {
69 | this._pendingNodes.add(node);
70 | type &= ~LOADING_BIT;
71 | } else if (this._pendingNodes.delete(node)) type &= ~LOADING_BIT;
72 | }
73 | if (type & ERROR_BIT) {
74 | if (flags & ERROR_BIT) {
75 | this._errorNodes.add(node);
76 | type &= ~ERROR_BIT;
77 | } else if (this._errorNodes.delete(node)) type &= ~ERROR_BIT;
78 | }
79 | }
80 | return type ? super.notify(node, type, flags) : true;
81 | }
82 | }
83 |
84 | export class CollectionQueue extends Queue {
85 | _collectionType: number;
86 | _nodes: Set = new Set();
87 | _disabled: Computation = new Computation(false, null);
88 | constructor(type: number) {
89 | super();
90 | this._collectionType = type;
91 | }
92 | run(type: number) {
93 | if (!type || this._disabled.read()) return;
94 | return super.run(type);
95 | }
96 | notify(node: Effect, type: number, flags: number) {
97 | if (!(type & this._collectionType)) return super.notify(node, type, flags);
98 | if (flags & this._collectionType) {
99 | this._nodes.add(node);
100 | if (this._nodes.size === 1) this._disabled.write(true);
101 | } else {
102 | this._nodes.delete(node);
103 | if (this._nodes.size === 0) this._disabled.write(false);
104 | }
105 | type &= ~this._collectionType;
106 | return type ? super.notify(node, type, flags) : true;
107 | }
108 | }
109 |
110 | export enum BoundaryMode {
111 | VISIBLE = "visible",
112 | HIDDEN = "hidden"
113 | }
114 | export function createBoundary(fn: () => T, condition: () => BoundaryMode) {
115 | const owner = new Owner();
116 | const queue = new ConditionalQueue(
117 | new Computation(undefined, () => condition() === BoundaryMode.HIDDEN)
118 | );
119 | const tree = createBoundChildren(owner, fn, queue, 0);
120 | new EagerComputation(undefined, () => {
121 | const disabled = queue._disabled.read();
122 | (tree as BoundaryComputation)._propagationMask = disabled ? ERROR_BIT | LOADING_BIT : 0;
123 | if (!disabled) {
124 | queue._pendingNodes.forEach(node => queue.notify(node, LOADING_BIT, LOADING_BIT));
125 | queue._errorNodes.forEach(node => queue.notify(node, ERROR_BIT, ERROR_BIT));
126 | queue._pendingNodes.clear();
127 | queue._errorNodes.clear();
128 | }
129 | });
130 | return () => (queue._disabled.read() ? undefined : tree.read());
131 | }
132 |
133 | function createCollectionBoundary(
134 | type: number,
135 | fn: () => any,
136 | fallback: (queue: CollectionQueue) => any
137 | ) {
138 | const owner = new Owner();
139 | const queue = new CollectionQueue(type);
140 | const tree = createBoundChildren(owner, fn, queue, type);
141 | const decision = new Computation(undefined, () => {
142 | if (!queue._disabled.read()) {
143 | const resolved = tree.read();
144 | if (!queue._disabled.read()) return resolved;
145 | }
146 | return fallback(queue);
147 | });
148 | return decision.read.bind(decision);
149 | }
150 |
151 | export function createSuspense(fn: () => any, fallback: () => any) {
152 | return createCollectionBoundary(LOADING_BIT, fn, () => fallback());
153 | }
154 |
155 | export function createErrorBoundary(
156 | fn: () => any,
157 | fallback: (error: unknown, reset: () => void) => U
158 | ) {
159 | return createCollectionBoundary(ERROR_BIT, fn, queue =>
160 | fallback(queue._nodes!.values().next().value!._error, () => {
161 | incrementClock();
162 | for (let node of queue._nodes) {
163 | (node as any)._state = STATE_DIRTY;
164 | (node as any)._queue?.enqueue((node as any)._type, node);
165 | }
166 | })
167 | );
168 | }
169 |
170 | export function flatten(
171 | children: any,
172 | options?: { skipNonRendered?: boolean; doNotUnwrap?: boolean }
173 | ): any {
174 | if (typeof children === "function" && !children.length) {
175 | if (options?.doNotUnwrap) return children;
176 | do {
177 | children = children();
178 | } while (typeof children === "function" && !children.length);
179 | }
180 | if (
181 | options?.skipNonRendered &&
182 | (children == null || children === true || children === false || children === "")
183 | )
184 | return;
185 |
186 | if (Array.isArray(children)) {
187 | let results: any[] = [];
188 | if (flattenArray(children, results, options)) {
189 | return () => {
190 | let nested = [];
191 | flattenArray(results, nested, { ...options, doNotUnwrap: false });
192 | return nested;
193 | };
194 | }
195 | return results;
196 | }
197 | return children;
198 | }
199 |
200 | function flattenArray(
201 | children: Array,
202 | results: any[] = [],
203 | options?: { skipNonRendered?: boolean; doNotUnwrap?: boolean }
204 | ): boolean {
205 | let notReady: NotReadyError | null = null;
206 | let needsUnwrap = false;
207 | for (let i = 0; i < children.length; i++) {
208 | try {
209 | let child = children[i];
210 | if (typeof child === "function" && !child.length) {
211 | if (options?.doNotUnwrap) {
212 | results.push(child);
213 | needsUnwrap = true;
214 | continue;
215 | }
216 | do {
217 | child = child();
218 | } while (typeof child === "function" && !child.length);
219 | }
220 | if (Array.isArray(child)) {
221 | needsUnwrap = flattenArray(child, results, options);
222 | } else if (
223 | options?.skipNonRendered &&
224 | (child == null || child === true || child === false || child === "")
225 | ) {
226 | // skip
227 | } else results.push(child);
228 | } catch (e) {
229 | if (!(e instanceof NotReadyError)) throw e;
230 | notReady = e;
231 | }
232 | }
233 | if (notReady) throw notReady;
234 | return needsUnwrap;
235 | }
236 |
--------------------------------------------------------------------------------
/src/core/constants.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * See https://dev.to/modderme123/super-charging-fine-grained-reactive-performance-47ph
3 | * State clean corresponds to a node where all the sources are fully up to date
4 | * State check corresponds to a node where some sources (including grandparents) may have changed
5 | * State dirty corresponds to a node where the direct parents of a node has changed
6 | */
7 | export const STATE_CLEAN = 0;
8 | export const STATE_CHECK = 1;
9 | export const STATE_DIRTY = 2;
10 | export const STATE_DISPOSED = 3;
11 |
12 | export const EFFECT_PURE = 0;
13 | export const EFFECT_RENDER = 1;
14 | export const EFFECT_USER = 2;
15 |
16 | export const SUPPORTS_PROXY = typeof Proxy === "function";
17 |
--------------------------------------------------------------------------------
/src/core/effect.ts:
--------------------------------------------------------------------------------
1 | import {
2 | EFFECT_PURE,
3 | EFFECT_RENDER,
4 | EFFECT_USER,
5 | STATE_CHECK,
6 | STATE_CLEAN,
7 | STATE_DIRTY,
8 | STATE_DISPOSED
9 | } from "./constants.js";
10 | import { Computation, latest, UNCHANGED, type SignalOptions } from "./core.js";
11 | import { EffectError } from "./error.js";
12 | import { ERROR_BIT, LOADING_BIT } from "./flags.js";
13 | import type { Owner } from "./owner.js";
14 | import { getClock } from "./scheduler.js";
15 |
16 | /**
17 | * Effects are the leaf nodes of our reactive graph. When their sources change, they are
18 | * automatically added to the queue of effects to re-execute, which will cause them to fetch their
19 | * sources and recompute
20 | */
21 | export class Effect extends Computation {
22 | _effect: (val: T, prev: T | undefined) => void | (() => void);
23 | _onerror: ((err: unknown) => void | (() => void)) | undefined;
24 | _cleanup: (() => void) | undefined;
25 | _modified: boolean = false;
26 | _prevValue: T | undefined;
27 | _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
28 | constructor(
29 | initialValue: T,
30 | compute: (val?: T) => T,
31 | effect: (val: T, prev: T | undefined) => void | (() => void),
32 | error?: (err: unknown) => void | (() => void),
33 | options?: SignalOptions & { render?: boolean; defer?: boolean }
34 | ) {
35 | super(initialValue, compute, options);
36 | this._effect = effect;
37 | this._onerror = error;
38 | this._prevValue = initialValue;
39 | this._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
40 | if (this._type === EFFECT_RENDER) {
41 | this._compute = p =>
42 | getClock() > this._queue.created && !(this._stateFlags & ERROR_BIT)
43 | ? latest(() => compute(p))
44 | : compute(p);
45 | }
46 | this._updateIfNecessary();
47 | !options?.defer &&
48 | (this._type === EFFECT_USER
49 | ? this._queue.enqueue(this._type, this._runEffect.bind(this))
50 | : this._runEffect(this._type));
51 | if (__DEV__ && !this._parent)
52 | console.warn("Effects created outside a reactive context will never be disposed");
53 | }
54 |
55 | override write(value: T, flags = 0): T {
56 | if (this._state == STATE_DIRTY) {
57 | const currentFlags = this._stateFlags;
58 | this._stateFlags = flags;
59 | if (this._type === EFFECT_RENDER) {
60 | this._queue.notify(this, LOADING_BIT | ERROR_BIT, flags);
61 | }
62 | }
63 | if (value === UNCHANGED) return this._value as T;
64 | this._value = value;
65 | this._modified = true;
66 |
67 | return value;
68 | }
69 |
70 | override _notify(state: number, skipQueue?: boolean): void {
71 | if (this._state >= state || skipQueue) return;
72 |
73 | if (this._state === STATE_CLEAN) this._queue.enqueue(this._type, this._runEffect.bind(this));
74 |
75 | this._state = state;
76 | }
77 |
78 | override _setError(error: unknown): void {
79 | this._error = error;
80 | this._cleanup?.();
81 | this._queue.notify(this, LOADING_BIT, 0);
82 | this._stateFlags = ERROR_BIT;
83 | if (this._type === EFFECT_USER) {
84 | try {
85 | return this._onerror
86 | ? (this._cleanup = this._onerror(error) as any)
87 | : console.error(new EffectError(this._effect, error));
88 | } catch (e) {
89 | error = e;
90 | }
91 | }
92 | if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT)) throw error;
93 | }
94 |
95 | override _disposeNode(): void {
96 | if (this._state === STATE_DISPOSED) return;
97 | this._effect = undefined as any;
98 | this._prevValue = undefined;
99 | this._onerror = undefined as any;
100 | this._cleanup?.();
101 | this._cleanup = undefined;
102 | super._disposeNode();
103 | }
104 |
105 | _runEffect(type: number): void {
106 | if (type) {
107 | if (this._modified && this._state !== STATE_DISPOSED) {
108 | this._cleanup?.();
109 | try {
110 | this._cleanup = this._effect(this._value!, this._prevValue) as any;
111 | } catch (e) {
112 | if (!this._queue.notify(this, ERROR_BIT, ERROR_BIT)) throw e;
113 | } finally {
114 | this._prevValue = this._value;
115 | this._modified = false;
116 | }
117 | }
118 | } else this._state !== STATE_CLEAN && runTop(this);
119 | }
120 | }
121 |
122 | function runComputation(this: Computation): void {
123 | this._state !== STATE_CLEAN && runTop(this);
124 | }
125 | export class EagerComputation extends Computation {
126 | constructor(initialValue: T, compute: () => T, options?: SignalOptions & { defer?: boolean }) {
127 | super(initialValue, compute, options);
128 | !options?.defer && this._updateIfNecessary();
129 | if (__DEV__ && !this._parent)
130 | console.warn("Eager Computations created outside a reactive context will never be disposed");
131 | }
132 |
133 | override _notify(state: number, skipQueue?: boolean): void {
134 | if (this._state >= state && !this._forceNotify) return;
135 |
136 | if (
137 | !skipQueue &&
138 | (this._state === STATE_CLEAN || (this._state === STATE_CHECK && this._forceNotify))
139 | )
140 | this._queue.enqueue(EFFECT_PURE, runComputation.bind(this));
141 |
142 | super._notify(state, skipQueue);
143 | }
144 | }
145 |
146 | export class ProjectionComputation extends Computation {
147 | constructor(compute: () => void) {
148 | super(undefined, compute);
149 | if (__DEV__ && !this._parent)
150 | console.warn("Eager Computations created outside a reactive context will never be disposed");
151 | }
152 | _notify(state: number, skipQueue?: boolean): void {
153 | if (this._state >= state && !this._forceNotify) return;
154 |
155 | if (
156 | !skipQueue &&
157 | (this._state === STATE_CLEAN || (this._state === STATE_CHECK && this._forceNotify))
158 | )
159 | this._queue.enqueue(EFFECT_PURE, runComputation.bind(this));
160 |
161 | super._notify(state, true);
162 | this._forceNotify = !!skipQueue; // they don't need to be forced themselves unless from above
163 | }
164 | }
165 |
166 | /**
167 | * When re-executing nodes, we want to be extra careful to avoid double execution of nested owners
168 | * In particular, it is important that we check all of our parents to see if they will rerun
169 | * See tests/createEffect: "should run parent effect before child effect" and "should run parent
170 | * memo before child effect"
171 | */
172 | function runTop(node: Computation): void {
173 | const ancestors: Computation[] = [];
174 |
175 | for (let current: Owner | null = node; current !== null; current = current._parent) {
176 | if (current._state !== STATE_CLEAN) {
177 | ancestors.push(current as Computation);
178 | }
179 | }
180 |
181 | for (let i = ancestors.length - 1; i >= 0; i--) {
182 | if (ancestors[i]._state !== STATE_DISPOSED) ancestors[i]._updateIfNecessary();
183 | }
184 | }
185 |
--------------------------------------------------------------------------------
/src/core/error.ts:
--------------------------------------------------------------------------------
1 | export class NotReadyError extends Error {}
2 |
3 | export class NoOwnerError extends Error {
4 | constructor() {
5 | super(__DEV__ ? "Context can only be accessed under a reactive root." : "");
6 | }
7 | }
8 |
9 | export class ContextNotFoundError extends Error {
10 | constructor() {
11 | super(
12 | __DEV__
13 | ? "Context must either be created with a default value or a value must be provided before accessing it."
14 | : ""
15 | );
16 | }
17 | }
18 |
19 | export class EffectError extends Error {
20 | constructor(effect: Function, cause: unknown) {
21 | super(__DEV__ ? `Uncaught error while running effect:\n\n ${effect.toString()}\n` : "");
22 | this.cause = cause;
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/core/flags.ts:
--------------------------------------------------------------------------------
1 | export type Flags = number;
2 |
3 | export const ERROR_OFFSET = 0;
4 | export const ERROR_BIT = 1 << ERROR_OFFSET;
5 | export const ERROR: unique symbol = Symbol(__DEV__ ? "ERROR" : 0);
6 |
7 | export const LOADING_OFFSET = 1;
8 | export const LOADING_BIT = 1 << LOADING_OFFSET;
9 | export const LOADING: unique symbol = Symbol(__DEV__ ? "LOADING" : 0);
10 |
11 | export const UNINITIALIZED_OFFSET = 2;
12 | export const UNINITIALIZED_BIT = 1 << UNINITIALIZED_OFFSET;
13 | export const UNINITIALIZED: unique symbol = Symbol(__DEV__ ? "UNINITIALIZED" : 0);
14 |
15 | export const DEFAULT_FLAGS = ERROR_BIT;
16 |
--------------------------------------------------------------------------------
/src/core/index.ts:
--------------------------------------------------------------------------------
1 | export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
2 | export {
3 | Owner,
4 | createContext,
5 | getContext,
6 | setContext,
7 | hasContext,
8 | getOwner,
9 | onCleanup,
10 | type Context,
11 | type ContextRecord,
12 | type Disposable
13 | } from "./owner.js";
14 | export {
15 | Computation,
16 | getObserver,
17 | isEqual,
18 | untrack,
19 | hasUpdated,
20 | isPending,
21 | latest,
22 | UNCHANGED,
23 | compute,
24 | runWithObserver,
25 | type SignalOptions
26 | } from "./core.js";
27 | export { Effect, EagerComputation } from "./effect.js";
28 | export { flushSync, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
29 | export * from "./constants.js";
30 | export * from "./flags.js";
31 |
--------------------------------------------------------------------------------
/src/core/owner.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Owner tracking is used to enable nested tracking scopes with automatic cleanup.
3 | * We also use owners to also keep track of which error handling context we are in.
4 | *
5 | * If you write the following
6 | *
7 | * const a = createOwner(() => {
8 | * const b = createOwner(() => {});
9 | *
10 | * const c = createOwner(() => {
11 | * const d = createOwner(() => {});
12 | * });
13 | *
14 | * const e = createOwner(() => {});
15 | * });
16 | *
17 | * The owner tree will look like this:
18 | *
19 | * a
20 | * /|\
21 | * b-c-e
22 | * |
23 | * d
24 | *
25 | * Following the _nextSibling pointers of each owner will first give you its children, and then its siblings (in reverse).
26 | * a -> e -> c -> d -> b
27 | *
28 | * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
29 | */
30 |
31 | import { STATE_CLEAN, STATE_DISPOSED } from "./constants.js";
32 | import type { Computation } from "./core.js";
33 | import { ContextNotFoundError, NoOwnerError } from "./error.js";
34 | import { globalQueue, type IQueue } from "./scheduler.js";
35 |
36 | export type ContextRecord = Record;
37 |
38 | export interface Disposable {
39 | (): void;
40 | }
41 |
42 | let currentOwner: Owner | null = null,
43 | defaultContext = {};
44 |
45 | /**
46 | * Returns the currently executing parent owner.
47 | */
48 | export function getOwner(): Owner | null {
49 | return currentOwner;
50 | }
51 |
52 | export function setOwner(owner: Owner | null): Owner | null {
53 | const out = currentOwner;
54 | currentOwner = owner;
55 | return out;
56 | }
57 |
58 | export class Owner {
59 | // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
60 | // However, the children are actually added in reverse creation order
61 | // See comment at the top of the file for an example of the _nextSibling traversal
62 | _parent: Owner | null = null;
63 | _nextSibling: Owner | null = null;
64 | _prevSibling: Owner | null = null;
65 |
66 | _state: number = STATE_CLEAN;
67 |
68 | _disposal: Disposable | Disposable[] | null = null;
69 | _context: ContextRecord = defaultContext;
70 | _queue: IQueue = globalQueue;
71 |
72 | _childCount: number = 0;
73 | id: string | null = null;
74 |
75 | constructor(id: string | null = null, skipAppend = false) {
76 | this.id = id;
77 | if (currentOwner) {
78 | !skipAppend && currentOwner.append(this);
79 | }
80 | }
81 |
82 | append(child: Owner): void {
83 | child._parent = this;
84 | child._prevSibling = this;
85 |
86 | if (this._nextSibling) this._nextSibling._prevSibling = child;
87 | child._nextSibling = this._nextSibling;
88 | this._nextSibling = child;
89 |
90 | if (this.id != null && child.id == null) child.id = this.getNextChildId();
91 | if (child._context !== this._context) {
92 | child._context = { ...this._context, ...child._context };
93 | }
94 |
95 | if (this._queue) child._queue = this._queue;
96 | }
97 |
98 | dispose(this: Owner, self = true): void {
99 | if (this._state === STATE_DISPOSED) return;
100 |
101 | let head = self ? this._prevSibling || this._parent : this,
102 | current = this._nextSibling,
103 | next: Computation | null = null;
104 |
105 | while (current && current._parent === this) {
106 | current.dispose(true);
107 | current._disposeNode();
108 | next = current._nextSibling as Computation | null;
109 | current._nextSibling = null;
110 | current = next;
111 | }
112 |
113 | this._childCount = 0;
114 | if (self) this._disposeNode();
115 | if (current) current._prevSibling = !self ? this : this._prevSibling;
116 | if (head) head._nextSibling = current;
117 | }
118 |
119 | _disposeNode(): void {
120 | if (this._prevSibling) this._prevSibling._nextSibling = null;
121 | this._parent = null;
122 | this._prevSibling = null;
123 | this._context = defaultContext;
124 | this._state = STATE_DISPOSED;
125 | this.emptyDisposal();
126 | }
127 |
128 | emptyDisposal(): void {
129 | if (!this._disposal) return;
130 |
131 | if (Array.isArray(this._disposal)) {
132 | for (let i = 0; i < this._disposal.length; i++) {
133 | const callable = this._disposal[i];
134 | callable.call(callable);
135 | }
136 | } else {
137 | this._disposal.call(this._disposal);
138 | }
139 |
140 | this._disposal = null;
141 | }
142 |
143 | getNextChildId(): string {
144 | if (this.id != null) return formatId(this.id, this._childCount++);
145 | throw new Error("Cannot get child id from owner without an id");
146 | }
147 | }
148 |
149 | export interface Context {
150 | readonly id: symbol;
151 | readonly defaultValue: T | undefined;
152 | }
153 |
154 | /**
155 | * Context provides a form of dependency injection. It is used to save from needing to pass
156 | * data as props through intermediate components. This function creates a new context object
157 | * that can be used with `getContext` and `setContext`.
158 | *
159 | * A default value can be provided here which will be used when a specific value is not provided
160 | * via a `setContext` call.
161 | */
162 | export function createContext(defaultValue?: T, description?: string): Context {
163 | return { id: Symbol(description), defaultValue };
164 | }
165 |
166 | /**
167 | * Attempts to get a context value for the given key.
168 | *
169 | * @throws `NoOwnerError` if there's no owner at the time of call.
170 | * @throws `ContextNotFoundError` if a context value has not been set yet.
171 | */
172 | export function getContext(context: Context, owner: Owner | null = currentOwner): T {
173 | if (!owner) {
174 | throw new NoOwnerError();
175 | }
176 |
177 | const value = hasContext(context, owner)
178 | ? (owner._context[context.id] as T)
179 | : context.defaultValue;
180 |
181 | if (isUndefined(value)) {
182 | throw new ContextNotFoundError();
183 | }
184 |
185 | return value;
186 | }
187 |
188 | /**
189 | * Attempts to set a context value on the parent scope with the given key.
190 | *
191 | * @throws `NoOwnerError` if there's no owner at the time of call.
192 | */
193 | export function setContext(context: Context, value?: T, owner: Owner | null = currentOwner) {
194 | if (!owner) {
195 | throw new NoOwnerError();
196 | }
197 |
198 | // We're creating a new object to avoid child context values being exposed to parent owners. If
199 | // we don't do this, everything will be a singleton and all hell will break lose.
200 | owner._context = {
201 | ...owner._context,
202 | [context.id]: isUndefined(value) ? context.defaultValue : value
203 | };
204 | }
205 |
206 | /**
207 | * Whether the given context is currently defined.
208 | */
209 | export function hasContext(context: Context, owner: Owner | null = currentOwner): boolean {
210 | return !isUndefined(owner?._context[context.id]);
211 | }
212 |
213 | /**
214 | * Runs an effect once before the reactive scope is disposed
215 | * @param fn an effect that should run only once on cleanup
216 | *
217 | * @returns the same {@link fn} function that was passed in
218 | *
219 | * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
220 | */
221 | export function onCleanup(fn: Disposable): Disposable {
222 | if (!currentOwner) return fn;
223 |
224 | const node = currentOwner;
225 |
226 | if (!node._disposal) {
227 | node._disposal = fn;
228 | } else if (Array.isArray(node._disposal)) {
229 | node._disposal.push(fn);
230 | } else {
231 | node._disposal = [node._disposal, fn];
232 | }
233 | return fn;
234 | }
235 |
236 | function formatId(prefix: string, id: number) {
237 | const num = id.toString(36),
238 | len = num.length - 1;
239 | return prefix + (len ? String.fromCharCode(64 + len) : "") + num;
240 | }
241 |
242 | function isUndefined(value: any): value is undefined {
243 | return typeof value === "undefined";
244 | }
245 |
--------------------------------------------------------------------------------
/src/core/scheduler.ts:
--------------------------------------------------------------------------------
1 | import { EFFECT_PURE, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
2 |
3 | let clock = 0;
4 | export function getClock() {
5 | return clock;
6 | }
7 | export function incrementClock(): void {
8 | clock++;
9 | }
10 |
11 | let scheduled = false;
12 | function schedule() {
13 | if (scheduled) return;
14 | scheduled = true;
15 | if (!globalQueue._running) queueMicrotask(flushSync);
16 | }
17 |
18 | type QueueCallback = (type: number) => void;
19 | export interface IQueue {
20 | enqueue(type: number, fn: QueueCallback): void;
21 | run(type: number): boolean | void;
22 | flush(): void;
23 | addChild(child: IQueue): void;
24 | removeChild(child: IQueue): void;
25 | created: number;
26 | notify(...args: any[]): boolean;
27 | _parent: IQueue | null;
28 | }
29 |
30 | let pureQueue: QueueCallback[] = [];
31 | export class Queue implements IQueue {
32 | _parent: IQueue | null = null;
33 | _running: boolean = false;
34 | _queues: [QueueCallback[], QueueCallback[]] = [[], []];
35 | _children: IQueue[] = [];
36 | created = clock;
37 | enqueue(type: number, fn: QueueCallback): void {
38 | pureQueue.push(fn);
39 | if (type) this._queues[type - 1].push(fn);
40 | schedule();
41 | }
42 | run(type: number) {
43 | if (type === EFFECT_PURE) {
44 | pureQueue.length && runQueue(pureQueue, type);
45 | pureQueue = [];
46 | return;
47 | } else if (this._queues[type - 1].length) {
48 | const effects = this._queues[type - 1];
49 | this._queues[type - 1] = [];
50 | runQueue(effects, type);
51 | }
52 | for (let i = 0; i < this._children.length; i++) {
53 | this._children[i].run(type);
54 | }
55 | }
56 | flush() {
57 | if (this._running) return;
58 | this._running = true;
59 | try {
60 | this.run(EFFECT_PURE);
61 | incrementClock();
62 | scheduled = false;
63 | this.run(EFFECT_RENDER);
64 | this.run(EFFECT_USER);
65 | } finally {
66 | this._running = false;
67 | }
68 | }
69 | addChild(child: IQueue) {
70 | this._children.push(child);
71 | child._parent = this;
72 | }
73 | removeChild(child: IQueue) {
74 | const index = this._children.indexOf(child);
75 | if (index >= 0) this._children.splice(index, 1);
76 | }
77 | notify(...args: any[]) {
78 | if (this._parent) return this._parent.notify(...args);
79 | return false;
80 | }
81 | }
82 |
83 | export const globalQueue = new Queue();
84 |
85 | /**
86 | * By default, changes are batched on the microtask queue which is an async process. You can flush
87 | * the queue synchronously to get the latest updates by calling `flushSync()`.
88 | */
89 | export function flushSync(): void {
90 | let count = 0;
91 | while (scheduled) {
92 | if (__DEV__ && ++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
93 | globalQueue.flush();
94 | }
95 | }
96 |
97 | function runQueue(queue: QueueCallback[], type: number): void {
98 | for (let i = 0; i < queue.length; i++) queue[i](type);
99 | }
100 |
--------------------------------------------------------------------------------
/src/globals.d.ts:
--------------------------------------------------------------------------------
1 | declare global {
2 | const __DEV__: boolean;
3 | const __TEST__: boolean;
4 | }
5 |
6 | export {};
7 |
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
1 | export {
2 | Computation,
3 | ContextNotFoundError,
4 | NoOwnerError,
5 | NotReadyError,
6 | Owner,
7 | Queue,
8 | createContext,
9 | flushSync,
10 | getContext,
11 | setContext,
12 | hasContext,
13 | getOwner,
14 | onCleanup,
15 | getObserver,
16 | isEqual,
17 | untrack,
18 | hasUpdated,
19 | isPending,
20 | latest,
21 | runWithObserver,
22 | SUPPORTS_PROXY
23 | } from "./core/index.js";
24 | export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
25 | export { mapArray, repeat, type Maybe } from "./map.js";
26 | export * from "./signals.js";
27 | export * from "./store/index.js";
28 | export {
29 | createSuspense,
30 | createErrorBoundary,
31 | createBoundary,
32 | flatten,
33 | type BoundaryMode
34 | } from "./boundaries.js";
35 |
--------------------------------------------------------------------------------
/src/map.ts:
--------------------------------------------------------------------------------
1 | import { Computation, compute, Owner } from "./core/index.js";
2 | import { runWithOwner } from "./signals.js";
3 | import type { Accessor } from "./signals.js";
4 | import { $TRACK } from "./store/index.js";
5 |
6 | export type Maybe = T | void | null | undefined | false;
7 |
8 | /**
9 | * Reactively transforms an array with a callback function - underlying helper for the `` control flow
10 | *
11 | * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
12 | *
13 | * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
14 | */
15 | export function mapArray(
16 | list: Accessor>,
17 | map: (value: Accessor- , index: Accessor) => MappedItem,
18 | options?: { keyed?: boolean | ((item: Item) => any); fallback?: Accessor }
19 | ): Accessor {
20 | const keyFn = typeof options?.keyed === "function" ? options.keyed : undefined;
21 | return updateKeyedMap.bind({
22 | _owner: new Owner(),
23 | _len: 0,
24 | _list: list,
25 | _items: [],
26 | _map: map,
27 | _mappings: [],
28 | _nodes: [],
29 | _key: keyFn,
30 | _rows: keyFn || options?.keyed === false ? [] : undefined,
31 | _indexes: map.length > 1 ? [] : undefined,
32 | _fallback: options?.fallback
33 | });
34 | }
35 |
36 | function updateKeyedMap(this: MapData): any[] {
37 | const newItems = this._list() || [],
38 | newLen = newItems.length;
39 | (newItems as any)[$TRACK]; // top level tracking
40 |
41 | runWithOwner(this._owner, () => {
42 | let i: number,
43 | j: number,
44 | mapper = this._rows
45 | ? () => {
46 | this._rows![j] = new Computation(newItems[j], null);
47 | this._indexes && (this._indexes![j] = new Computation(j, null));
48 | return this._map(
49 | Computation.prototype.read.bind(this._rows![j]),
50 | this._indexes
51 | ? Computation.prototype.read.bind(this._indexes![j])
52 | : (undefined as any)
53 | );
54 | }
55 | : this._indexes
56 | ? () => {
57 | const item = newItems[j];
58 | this._indexes![j] = new Computation(j, null);
59 | return this._map(() => item, Computation.prototype.read.bind(this._indexes![j]));
60 | }
61 | : () => {
62 | const item = newItems[j];
63 | return (this._map as (value: () => Item) => MappedItem)(() => item);
64 | };
65 |
66 | // fast path for empty arrays
67 | if (newLen === 0) {
68 | if (this._len !== 0) {
69 | this._owner.dispose(false);
70 | this._nodes = [];
71 | this._items = [];
72 | this._mappings = [];
73 | this._len = 0;
74 | this._rows && (this._rows = []);
75 | this._indexes && (this._indexes = []);
76 | }
77 | if (this._fallback && !this._mappings[0]) {
78 | // create fallback
79 | this._mappings[0] = compute(
80 | (this._nodes[0] = new Owner()),
81 | this._fallback,
82 | null
83 | );
84 | }
85 | }
86 | // fast path for new create
87 | else if (this._len === 0) {
88 | // dispose previous fallback
89 | if (this._nodes[0]) this._nodes[0].dispose();
90 | this._mappings = new Array(newLen);
91 |
92 | for (j = 0; j < newLen; j++) {
93 | this._items[j] = newItems[j];
94 | this._mappings[j] = compute((this._nodes[j] = new Owner()), mapper, null);
95 | }
96 |
97 | this._len = newLen;
98 | } else {
99 | let start: number,
100 | end: number,
101 | newEnd: number,
102 | item: Item,
103 | key: any,
104 | newIndices: Map,
105 | newIndicesNext: number[],
106 | temp: MappedItem[] = new Array(newLen),
107 | tempNodes: Owner[] = new Array(newLen),
108 | tempRows: Computation
- [] | undefined = this._rows ? new Array(newLen) : undefined,
109 | tempIndexes: Computation[] | undefined = this._indexes
110 | ? new Array(newLen)
111 | : undefined;
112 |
113 | // skip common prefix
114 | for (
115 | start = 0, end = Math.min(this._len, newLen);
116 | start < end &&
117 | (this._items[start] === newItems[start] ||
118 | (this._rows && compare(this._key, this._items[start], newItems[start])));
119 | start++
120 | ) {
121 | if (this._rows) this._rows[start].write(newItems[start]);
122 | }
123 |
124 | // common suffix
125 | for (
126 | end = this._len - 1, newEnd = newLen - 1;
127 | end >= start &&
128 | newEnd >= start &&
129 | (this._items[end] === newItems[newEnd] ||
130 | (this._rows && compare(this._key, this._items[end], newItems[newEnd])));
131 | end--, newEnd--
132 | ) {
133 | temp[newEnd] = this._mappings[end];
134 | tempNodes[newEnd] = this._nodes[end];
135 | tempRows && (tempRows[newEnd] = this._rows![end]);
136 | tempIndexes && (tempIndexes[newEnd] = this._indexes![end]);
137 | }
138 |
139 | // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
140 | newIndices = new Map();
141 | newIndicesNext = new Array(newEnd + 1);
142 | for (j = newEnd; j >= start; j--) {
143 | item = newItems[j];
144 | key = this._key ? this._key(item) : item;
145 | i = newIndices.get(key)!;
146 | newIndicesNext[j] = i === undefined ? -1 : i;
147 | newIndices.set(key, j);
148 | }
149 |
150 | // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, exit them
151 | for (i = start; i <= end; i++) {
152 | item = this._items[i];
153 | key = this._key ? this._key(item) : item;
154 | j = newIndices.get(key)!;
155 | if (j !== undefined && j !== -1) {
156 | temp[j] = this._mappings[i];
157 | tempNodes[j] = this._nodes[i];
158 | tempRows && (tempRows[j] = this._rows![i]);
159 | tempIndexes && (tempIndexes[j] = this._indexes![i]);
160 | j = newIndicesNext[j];
161 | newIndices.set(key, j);
162 | } else this._nodes[i].dispose();
163 | }
164 |
165 | // 2) set all the new values, pulling from the temp array if copied, otherwise entering the new value
166 | for (j = start; j < newLen; j++) {
167 | if (j in temp) {
168 | this._mappings[j] = temp[j];
169 | this._nodes[j] = tempNodes[j];
170 | if (tempRows) {
171 | this._rows![j] = tempRows[j];
172 | this._rows![j].write(newItems[j]);
173 | }
174 | if (tempIndexes) {
175 | this._indexes![j] = tempIndexes[j];
176 | this._indexes![j].write(j);
177 | }
178 | } else {
179 | this._mappings[j] = compute((this._nodes[j] = new Owner()), mapper, null);
180 | }
181 | }
182 |
183 | // 3) in case the new set is shorter than the old, set the length of the mapped array
184 | this._mappings = this._mappings.slice(0, (this._len = newLen));
185 |
186 | // 4) save a copy of the mapped items for the next update
187 | this._items = newItems.slice(0);
188 | }
189 | });
190 |
191 | return this._mappings;
192 | }
193 |
194 | /**
195 | * Reactively repeats a callback function the count provided - underlying helper for the `` control flow
196 | *
197 | * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
198 | */
199 | export function repeat(
200 | count: Accessor,
201 | map: (index: number) => any,
202 | options?: {
203 | from?: Accessor;
204 | fallback?: Accessor;
205 | }
206 | ): Accessor {
207 | return updateRepeat.bind({
208 | _owner: new Owner(),
209 | _len: 0,
210 | _offset: 0,
211 | _count: count,
212 | _map: map,
213 | _nodes: [],
214 | _mappings: [],
215 | _from: options?.from,
216 | _fallback: options?.fallback
217 | });
218 | }
219 |
220 | function updateRepeat(this: RepeatData): any[] {
221 | const newLen = this._count();
222 | const from = this._from?.() || 0;
223 | runWithOwner(this._owner, () => {
224 | if (newLen === 0) {
225 | if (this._len !== 0) {
226 | this._owner.dispose(false);
227 | this._nodes = [];
228 | this._mappings = [];
229 | this._len = 0;
230 | }
231 | if (this._fallback && !this._mappings[0]) {
232 | // create fallback
233 | this._mappings[0] = compute(
234 | (this._nodes[0] = new Owner()),
235 | this._fallback,
236 | null
237 | );
238 | }
239 | return;
240 | }
241 | const to = from + newLen;
242 | const prevTo = this._offset + this._len;
243 |
244 | // remove fallback
245 | if (this._len === 0 && this._nodes[0]) this._nodes[0].dispose();
246 |
247 | // clear the end
248 | for (let i = to; i < prevTo; i++) this._nodes[i - this._offset].dispose();
249 |
250 | if (this._offset < from) {
251 | // clear beginning
252 | let i = this._offset;
253 | while (i < from && i < this._len) this._nodes[i++].dispose();
254 | // shift indexes
255 | this._nodes.splice(0, from - this._offset);
256 | this._mappings.splice(0, from - this._offset);
257 | } else if (this._offset > from) {
258 | // shift indexes
259 | let i = prevTo - this._offset - 1;
260 | let difference = this._offset - from;
261 | this._nodes.length = this._mappings.length = newLen;
262 | while (i >= difference) {
263 | this._nodes[i] = this._nodes[i - difference];
264 | this._mappings[i] = this._mappings[i - difference];
265 | i--;
266 | }
267 | for (let i = 0; i < difference; i++) {
268 | this._mappings[i] = compute(
269 | (this._nodes[i] = new Owner()),
270 | () => this._map(i + from),
271 | null
272 | );
273 | }
274 | }
275 |
276 | for (let i = prevTo; i < to; i++) {
277 | this._mappings[i - from] = compute(
278 | (this._nodes[i - from] = new Owner()),
279 | () => this._map(i),
280 | null
281 | );
282 | }
283 | this._mappings = this._mappings.slice(0, newLen);
284 | this._offset = from;
285 | this._len = newLen;
286 | });
287 | return this._mappings;
288 | }
289 |
290 | function compare
- (key: ((i: any) => any) | undefined, a: Item, b: Item): boolean {
291 | return key ? key(a) === key(b) : true;
292 | }
293 |
294 | interface RepeatData {
295 | _owner: Owner;
296 | _len: number;
297 | _count: Accessor;
298 | _map: (index: number) => MappedItem;
299 | _mappings: MappedItem[];
300 | _nodes: Owner[];
301 | _offset: number;
302 | _from?: Accessor;
303 | _fallback?: Accessor;
304 | }
305 |
306 | interface MapData
- {
307 | _owner: Owner;
308 | _len: number;
309 | _list: Accessor>;
310 | _items: Item[];
311 | _mappings: MappedItem[];
312 | _nodes: Owner[];
313 | _map: (value: Accessor, index: Accessor) => any;
314 | _key: ((i: any) => any) | undefined;
315 | _rows?: Computation
- [];
316 | _indexes?: Computation[];
317 | _fallback?: Accessor;
318 | }
319 |
--------------------------------------------------------------------------------
/src/signals.ts:
--------------------------------------------------------------------------------
1 | import type { SignalOptions } from "./core/index.js";
2 | import {
3 | Computation,
4 | compute,
5 | EagerComputation,
6 | Effect,
7 | ERROR_BIT,
8 | getOwner,
9 | NotReadyError,
10 | onCleanup,
11 | Owner,
12 | STATE_DISPOSED,
13 | untrack
14 | } from "./core/index.js";
15 |
16 | export type Accessor = () => T;
17 |
18 | export type Setter = {
19 | (
20 | ...args: undefined extends T ? [] : [value: Exclude | ((prev: T) => U)]
21 | ): undefined extends T ? undefined : U;
22 | (value: (prev: T) => U): U;
23 | (value: Exclude): U;
24 | (value: Exclude | ((prev: T) => U)): U;
25 | };
26 |
27 | export type Signal = [get: Accessor, set: Setter];
28 |
29 | export type ComputeFunction = (v: Prev) => Next;
30 | export type EffectFunction = (
31 | v: Next,
32 | p?: Prev
33 | ) => (() => void) | void;
34 |
35 | export interface EffectOptions {
36 | name?: string;
37 | defer?: boolean;
38 | }
39 | export interface MemoOptions {
40 | name?: string;
41 | equals?: false | ((prev: T, next: T) => boolean);
42 | }
43 |
44 | // Magic type that when used at sites where generic types are inferred from, will prevent those sites from being involved in the inference.
45 | // https://github.com/microsoft/TypeScript/issues/14829
46 | // TypeScript Discord conversation: https://discord.com/channels/508357248330760243/508357248330760249/911266491024949328
47 | export type NoInfer = [T][T extends any ? 0 : never];
48 |
49 | /**
50 | * Creates a simple reactive state with a getter and setter
51 | * ```typescript
52 | * const [state: Accessor, setState: Setter] = createSignal(
53 | * value: T,
54 | * options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
55 | * )
56 | * ```
57 | * @param value initial value of the state; if empty, the state's type will automatically extended with undefined; otherwise you need to extend the type manually if you want setting to undefined not be an error
58 | * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
59 | *
60 | * @returns ```typescript
61 | * [state: Accessor, setState: Setter]
62 | * ```
63 | * * the Accessor is a function that returns the current value and registers each call to the reactive root
64 | * * the Setter is a function that allows directly setting or mutating the value:
65 | * ```typescript
66 | * const [count, setCount] = createSignal(0);
67 | * setCount(count => count + 1);
68 | * ```
69 | *
70 | * @description https://docs.solidjs.com/reference/basic-reactivity/create-signal
71 | */
72 | export function createSignal(): Signal;
73 | export function createSignal(value: Exclude, options?: SignalOptions): Signal;
74 | export function createSignal(
75 | fn: ComputeFunction,
76 | initialValue?: T,
77 | options?: SignalOptions
78 | ): Signal;
79 | export function createSignal(
80 | first?: T | ComputeFunction,
81 | second?: T | SignalOptions,
82 | third?: SignalOptions
83 | ): Signal {
84 | if (typeof first === "function") {
85 | const memo = createMemo>(p => {
86 | const node = new Computation(
87 | (first as (prev?: T) => T)(p ? untrack(p[0]) : (second as T)),
88 | null,
89 | third
90 | );
91 | return [node.read.bind(node), node.write.bind(node)] as Signal;
92 | });
93 | return [() => memo()[0](), (value => memo()[1](value)) as Setter];
94 | }
95 | const o = getOwner();
96 | const needsId = o?.id != null;
97 | const node = new Computation(
98 | first,
99 | null,
100 | needsId ? { id: o.getNextChildId(), ...second } : (second as SignalOptions)
101 | );
102 | return [node.read.bind(node), node.write.bind(node) as Setter];
103 | }
104 |
105 | /**
106 | * Creates a readonly derived reactive memoized signal
107 | * ```typescript
108 | * export function createMemo(
109 | * compute: (v: T) => T,
110 | * value?: T,
111 | * options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
112 | * ): () => T;
113 | * ```
114 | * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
115 | * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
116 | * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
117 | *
118 | * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
119 | */
120 | // The extra Prev generic parameter separates inference of the compute input
121 | // parameter type from inference of the compute return type, so that the effect
122 | // return type is always used as the memo Accessor's return type.
123 | export function createMemo(
124 | compute: ComputeFunction, Next>
125 | ): Accessor;
126 | export function createMemo(
127 | compute: ComputeFunction,
128 | value: Init,
129 | options?: MemoOptions
130 | ): Accessor;
131 | export function createMemo(
132 | compute: ComputeFunction,
133 | value?: Init,
134 | options?: MemoOptions
135 | ): Accessor {
136 | let node: Computation | undefined = new Computation(
137 | value as any,
138 | compute as any,
139 | options
140 | );
141 | let resolvedValue: Next;
142 | return () => {
143 | if (node) {
144 | if (node._state === STATE_DISPOSED) {
145 | node = undefined;
146 | return resolvedValue;
147 | }
148 | resolvedValue = node.wait();
149 | // no sources so will never update so can be disposed.
150 | // additionally didn't create nested reactivity so can be disposed.
151 | if (!node._sources?.length && node._nextSibling?._parent !== node) {
152 | node.dispose();
153 | node = undefined;
154 | }
155 | }
156 | return resolvedValue;
157 | };
158 | }
159 |
160 | /**
161 | * Creates a readonly derived async reactive memoized signal
162 | * ```typescript
163 | * export function createAsync(
164 | * compute: (v: T) => Promise | T,
165 | * value?: T,
166 | * options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
167 | * ): () => T;
168 | * ```
169 | * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
170 | * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
171 | * @param options allows to set a name in dev mode for debugging purposes and use a custom comparison function in equals
172 | *
173 | * @description https://docs.solidjs.com/reference/basic-reactivity/create-async
174 | */
175 | export function createAsync(
176 | compute: (prev?: T) => Promise | AsyncIterable | T,
177 | value?: T,
178 | options?: MemoOptions
179 | ): Accessor {
180 | const node = new EagerComputation(
181 | value as T,
182 | (p?: T) => {
183 | const source = compute(p);
184 | const isPromise = source instanceof Promise;
185 | const iterator = source[Symbol.asyncIterator];
186 | if (!isPromise && !iterator) {
187 | return source as T;
188 | }
189 | let abort = false;
190 | onCleanup(() => (abort = true));
191 | if (isPromise) {
192 | source.then(
193 | value3 => {
194 | if (abort) return;
195 | node.write(value3, 0, true);
196 | },
197 | error => {
198 | if (abort) return;
199 | node._setError(error);
200 | }
201 | );
202 | } else {
203 | (async () => {
204 | try {
205 | for await (let value3 of source as AsyncIterable) {
206 | if (abort) return;
207 | node.write(value3, 0, true);
208 | }
209 | } catch (error: any) {
210 | if (abort) return;
211 | node.write(error, ERROR_BIT);
212 | }
213 | })();
214 | }
215 | throw new NotReadyError();
216 | },
217 | options
218 | );
219 | return node.wait.bind(node) as Accessor;
220 | }
221 |
222 | /**
223 | * Creates a reactive effect that runs after the render phase
224 | * ```typescript
225 | * export function createEffect(
226 | * compute: (prev: T) => T,
227 | * effect: (v: T, prev: T) => (() => void) | void,
228 | * value?: T,
229 | * options?: { name?: string }
230 | * ): void;
231 | * ```
232 | * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
233 | * @param effect a function that receives the new value and is used to perform side effects, return a cleanup function to run on disposal
234 | * @param error an optional function that receives an error if thrown during the computation
235 | * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
236 | * @param options allows to set a name in dev mode for debugging purposes
237 | *
238 | * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
239 | */
240 | export function createEffect(
241 | compute: ComputeFunction, Next>,
242 | effect: EffectFunction, Next>,
243 | error?: (err: unknown) => void
244 | ): void;
245 | export function createEffect(
246 | compute: ComputeFunction,
247 | effect: EffectFunction,
248 | error: ((err: unknown) => void) | undefined,
249 | value: Init,
250 | options?: EffectOptions
251 | ): void;
252 | export function createEffect(
253 | compute: ComputeFunction,
254 | effect: EffectFunction,
255 | error?: (err: unknown) => void,
256 | value?: Init,
257 | options?: EffectOptions
258 | ): void {
259 | void new Effect(
260 | value as any,
261 | compute as any,
262 | effect,
263 | error,
264 | __DEV__ ? { ...options, name: options?.name ?? "effect" } : options
265 | );
266 | }
267 |
268 | /**
269 | * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
270 | * ```typescript
271 | * export function createRenderEffect(
272 | * compute: (prev: T) => T,
273 | * effect: (v: T, prev: T) => (() => void) | void,
274 | * value?: T,
275 | * options?: { name?: string }
276 | * ): void;
277 | * ```
278 | * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
279 | * @param effect a function that receives the new value and is used to perform side effects
280 | * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
281 | * @param options allows to set a name in dev mode for debugging purposes
282 | *
283 | * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
284 | */
285 | export function createRenderEffect(
286 | compute: ComputeFunction, Next>,
287 | effect: EffectFunction, Next>
288 | ): void;
289 | export function createRenderEffect(
290 | compute: ComputeFunction,
291 | effect: EffectFunction,
292 | value: Init,
293 | options?: EffectOptions
294 | ): void;
295 | export function createRenderEffect(
296 | compute: ComputeFunction,
297 | effect: EffectFunction,
298 | value?: Init,
299 | options?: EffectOptions
300 | ): void {
301 | void new Effect(value as any, compute as any, effect, undefined, {
302 | render: true,
303 | ...(__DEV__ ? { ...options, name: options?.name ?? "effect" } : options)
304 | });
305 | }
306 |
307 | /**
308 | * Creates a new non-tracked reactive context with manual disposal
309 | *
310 | * @param fn a function in which the reactive state is scoped
311 | * @returns the output of `fn`.
312 | *
313 | * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
314 | */
315 | export function createRoot(
316 | init: ((dispose: () => void) => T) | (() => T),
317 | options?: { id: string }
318 | ): T {
319 | const owner = new Owner(options?.id);
320 | return compute(owner, !init.length ? (init as () => T) : () => init(() => owner.dispose()), null);
321 | }
322 |
323 | /**
324 | * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
325 | * This method untracks the current scope.
326 | *
327 | * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
328 | */
329 | export function runWithOwner(owner: Owner | null, run: () => T): T {
330 | return compute(owner, run, null);
331 | }
332 |
333 | /**
334 | * Returns a promise of the resolved value of a reactive expression
335 | * @param fn a reactive expression to resolve
336 | */
337 | export function resolve(fn: () => T): Promise {
338 | return new Promise((res, rej) => {
339 | createRoot(dispose => {
340 | new EagerComputation(undefined, () => {
341 | try {
342 | res(fn());
343 | } catch (err) {
344 | if (err instanceof NotReadyError) throw err;
345 | rej(err);
346 | }
347 | dispose();
348 | });
349 | });
350 | });
351 | }
352 |
353 | export type TryCatchResult = [undefined, T] | [E];
354 | export function tryCatch(fn: () => Promise): Promise>;
355 | export function tryCatch(fn: () => T): TryCatchResult;
356 | export function tryCatch(
357 | fn: () => T | Promise
358 | ): TryCatchResult | Promise> {
359 | try {
360 | const v = fn();
361 | if (v instanceof Promise) {
362 | return v.then(
363 | v => [undefined, v],
364 | e => {
365 | if (e instanceof NotReadyError) throw e;
366 | return [e as E];
367 | }
368 | );
369 | }
370 | return [undefined, v];
371 | } catch (e) {
372 | if (e instanceof NotReadyError) throw e;
373 | return [e as E];
374 | }
375 | }
376 |
--------------------------------------------------------------------------------
/src/store/index.ts:
--------------------------------------------------------------------------------
1 | export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./store.js";
2 | export type { Merge, Omit } from "./utils.js";
3 |
4 | export { unwrap, isWrappable, createStore, deep, $RAW, $TRACK, $PROXY, $TARGET } from "./store.js";
5 |
6 | export { createProjection } from "./projection.js";
7 |
8 | export { reconcile } from "./reconcile.js";
9 |
10 | export { merge, omit } from "./utils.js";
11 |
--------------------------------------------------------------------------------
/src/store/projection.ts:
--------------------------------------------------------------------------------
1 | import { ProjectionComputation } from "../core/effect.js";
2 | import { createStore, isWrappable, type Store, type StoreSetter } from "./store.js";
3 |
4 | /**
5 | * Creates a mutable derived value
6 | *
7 | * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
8 | */
9 | export function createProjection(
10 | fn: (draft: T) => void,
11 | initialValue: T = {} as T
12 | ): Store {
13 | const [store] = createStore(fn, initialValue);
14 | return store;
15 | }
16 |
17 | export function wrapProjection(
18 | fn: (draft: T) => void,
19 | store: Store,
20 | setStore: StoreSetter
21 | ): [Store, StoreSetter] {
22 | const node = new ProjectionComputation(() => {
23 | setStore(fn);
24 | });
25 | const wrapped = new WeakMap();
26 | return [wrap(store, node, wrapped), setStore];
27 | }
28 |
29 | function wrap(source, node, wrapped) {
30 | if (wrapped.has(source)) return wrapped.get(source);
31 | const wrap = new Proxy(source, {
32 | get(target, property) {
33 | node.read();
34 | const v = target[property];
35 | return isWrappable(v) ? wrap(v, node, wrapped) : v;
36 | },
37 | set() {
38 | throw new Error("Projections are readonly");
39 | },
40 | deleteProperty() {
41 | throw new Error("Projections are readonly");
42 | }
43 | });
44 | wrapped.set(source, wrap);
45 | return wrap;
46 | }
47 |
--------------------------------------------------------------------------------
/src/store/reconcile.ts:
--------------------------------------------------------------------------------
1 | import {
2 | $PROXY,
3 | $TARGET,
4 | $TRACK,
5 | isWrappable,
6 | STORE_HAS,
7 | STORE_NODE,
8 | STORE_VALUE,
9 | unwrap,
10 | wrap
11 | } from "./store.js";
12 |
13 | function applyState(next: any, state: any, keyFn: (item: NonNullable) => any) {
14 | const target = state?.[$TARGET];
15 | if (!target) return;
16 | const previous = target[STORE_VALUE];
17 | if (next === previous) return;
18 |
19 | // swap
20 | Object.defineProperty(next, $PROXY, {
21 | value: previous[$PROXY],
22 | writable: true
23 | });
24 | previous[$PROXY] = null;
25 | target[STORE_VALUE] = next;
26 |
27 | // merge
28 | if (Array.isArray(previous)) {
29 | let changed = false;
30 | if (next.length && previous.length && next[0] && keyFn(next[0]) != null) {
31 | let i, j, start, end, newEnd, item, newIndicesNext, keyVal; // common prefix
32 |
33 | for (
34 | start = 0, end = Math.min(previous.length, next.length);
35 | start < end &&
36 | (previous[start] === next[start] ||
37 | (previous[start] && next[start] && keyFn(previous[start]) === keyFn(next[start])));
38 | start++
39 | ) {
40 | applyState(next[start], wrap(previous[start]), keyFn);
41 | }
42 |
43 | const temp = new Array(next.length),
44 | newIndices = new Map();
45 |
46 | for (
47 | end = previous.length - 1, newEnd = next.length - 1;
48 | end >= start &&
49 | newEnd >= start &&
50 | (previous[end] === next[newEnd] ||
51 | (previous[end] && next[newEnd] && keyFn(previous[end]) === keyFn(next[newEnd])));
52 | end--, newEnd--
53 | ) {
54 | temp[newEnd] = previous[end];
55 | }
56 |
57 | if (start > newEnd || start > end) {
58 | for (j = start; j <= newEnd; j++) {
59 | changed = true;
60 | target[STORE_NODE][j]?.write(wrap(next[j]));
61 | }
62 |
63 | for (; j < next.length; j++) {
64 | changed = true;
65 | const wrapped = wrap(temp[j]);
66 | target[STORE_NODE][j]?.write(wrapped);
67 | applyState(next[j], wrapped, keyFn);
68 | }
69 |
70 | changed && target[STORE_NODE][$TRACK]?.write(void 0);
71 | previous.length !== next.length && target[STORE_NODE].length?.write(next.length);
72 | return;
73 | }
74 |
75 | newIndicesNext = new Array(newEnd + 1);
76 |
77 | for (j = newEnd; j >= start; j--) {
78 | item = next[j];
79 | keyVal = item ? keyFn(item) : item;
80 | i = newIndices.get(keyVal);
81 | newIndicesNext[j] = i === undefined ? -1 : i;
82 | newIndices.set(keyVal, j);
83 | }
84 |
85 | for (i = start; i <= end; i++) {
86 | item = previous[i];
87 | keyVal = item ? keyFn(item) : item;
88 | j = newIndices.get(keyVal);
89 |
90 | if (j !== undefined && j !== -1) {
91 | temp[j] = previous[i];
92 | j = newIndicesNext[j];
93 | newIndices.set(keyVal, j);
94 | }
95 | }
96 |
97 | for (j = start; j < next.length; j++) {
98 | if (j in temp) {
99 | const wrapped = wrap(temp[j]);
100 | target[STORE_NODE][j]?.write(wrapped);
101 | applyState(next[j], wrapped, keyFn);
102 | } else target[STORE_NODE][j]?.write(wrap(next[j]));
103 | }
104 | if (start < next.length) changed = true;
105 | } else if (previous.length && next.length) {
106 | for (let i = 0, len = next.length; i < len; i++) {
107 | isWrappable(previous[i]) && applyState(next[i], wrap(previous[i]), keyFn);
108 | }
109 | }
110 |
111 | if (previous.length !== next.length) {
112 | changed = true;
113 | target[STORE_NODE].length?.write(next.length);
114 | }
115 | changed && target[STORE_NODE][$TRACK]?.write(void 0);
116 | return;
117 | }
118 |
119 | // values
120 | let nodes = target[STORE_NODE];
121 | if (nodes) {
122 | const keys = Object.keys(nodes);
123 | for (let i = 0, len = keys.length; i < len; i++) {
124 | const node = nodes[keys[i]];
125 | const previousValue = unwrap(previous[keys[i]], false);
126 | let nextValue = unwrap(next[keys[i]], false);
127 | if (previousValue === nextValue) continue;
128 | if (
129 | !previousValue ||
130 | !isWrappable(previousValue) ||
131 | (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
132 | )
133 | node.write(isWrappable(nextValue) ? wrap(nextValue) : nextValue);
134 | else applyState(nextValue, wrap(previousValue), keyFn);
135 | }
136 | }
137 |
138 | // has
139 | if ((nodes = target[STORE_HAS])) {
140 | const keys = Object.keys(nodes);
141 | for (let i = 0, len = keys.length; i < len; i++) {
142 | nodes[keys[i]].write(keys[i] in next);
143 | }
144 | }
145 | }
146 |
147 | export function reconcile(
148 | value: T,
149 | key: string | ((item: NonNullable) => any)
150 | ) {
151 | return (state: U) => {
152 | const keyFn = typeof key === "string" ? item => item[key] : key;
153 | if (keyFn(value) !== keyFn(state))
154 | throw new Error("Cannot reconcile states with different identity");
155 | applyState(value, state, keyFn);
156 | return state as T;
157 | };
158 | }
159 |
--------------------------------------------------------------------------------
/src/store/store.ts:
--------------------------------------------------------------------------------
1 | import { Computation, getObserver, isEqual, untrack } from "../core/index.js";
2 | import { wrapProjection } from "./projection.js";
3 |
4 | export type Store = Readonly;
5 | export type StoreSetter = (fn: (state: T) => void) => void;
6 |
7 | type DataNode = Computation;
8 | type DataNodes = Record;
9 |
10 | const $RAW = Symbol(__DEV__ ? "STORE_RAW" : 0),
11 | $TRACK = Symbol(__DEV__ ? "STORE_TRACK" : 0),
12 | $DEEP = Symbol(__DEV__ ? "STORE_DEEP" : 0),
13 | $TARGET = Symbol(__DEV__ ? "STORE_TARGET" : 0),
14 | $PROXY = Symbol(__DEV__ ? "STORE_PROXY" : 0);
15 |
16 | const PARENTS = new WeakMap>();
17 |
18 | export const STORE_VALUE = "v",
19 | STORE_NODE = "n",
20 | STORE_HAS = "h";
21 |
22 | export { $PROXY, $TRACK, $RAW, $TARGET };
23 | export type StoreNode = {
24 | [STORE_VALUE]: Record;
25 | [STORE_NODE]?: DataNodes;
26 | [STORE_HAS]?: DataNodes;
27 | };
28 |
29 | export namespace SolidStore {
30 | export interface Unwrappable {}
31 | }
32 |
33 | export type NotWrappable =
34 | | string
35 | | number
36 | | bigint
37 | | symbol
38 | | boolean
39 | | Function
40 | | null
41 | | undefined
42 | | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
43 |
44 | export function wrap>(value: T): T {
45 | let p = value[$PROXY];
46 | if (!p) {
47 | let target;
48 | if (Array.isArray(value)) {
49 | target = [];
50 | target.v = value;
51 | } else target = { v: value };
52 | Object.defineProperty(value, $PROXY, {
53 | value: (p = new Proxy(target, proxyTraps)),
54 | writable: true
55 | });
56 | }
57 | return p;
58 | }
59 |
60 | export function isWrappable(obj: T | NotWrappable): obj is T;
61 | export function isWrappable(obj: any) {
62 | return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
63 | }
64 |
65 | /**
66 | * Returns the underlying data in the store without a proxy.
67 | * @param item store proxy object
68 | * @example
69 | * ```js
70 | * const initial = {z...};
71 | * const [state, setState] = createStore(initial);
72 | * initial === state; // => false
73 | * initial === unwrap(state); // => true
74 | * ```
75 | */
76 | export function unwrap(item: T, deep?: boolean, set?: Set): T;
77 | export function unwrap(item: any, deep = true, set?: Set): T {
78 | let result, unwrapped, v, prop;
79 | if ((result = item != null && item[$RAW])) return result;
80 | if (!deep) return item;
81 | if (!isWrappable(item) || set?.has(item)) return item;
82 | if (!set) set = new Set();
83 | set.add(item);
84 | if (Array.isArray(item)) {
85 | for (let i = 0, l = item.length; i < l; i++) {
86 | v = item[i];
87 | if ((unwrapped = unwrap(v, deep, set)) !== v) item[i] = unwrapped;
88 | }
89 | } else {
90 | if (!deep) return item;
91 | const keys = Object.keys(item);
92 | for (let i = 0, l = keys.length; i < l; i++) {
93 | prop = keys[i];
94 | const desc = Object.getOwnPropertyDescriptor(item, prop)!;
95 | if (desc.get) continue;
96 | v = item[prop];
97 | if ((unwrapped = unwrap(v, deep, set)) !== v) item[prop] = unwrapped;
98 | }
99 | }
100 | return item;
101 | }
102 |
103 | function getNodes(target: StoreNode, type: typeof STORE_NODE | typeof STORE_HAS): DataNodes {
104 | let nodes = target[type];
105 | if (!nodes) target[type] = nodes = Object.create(null) as DataNodes;
106 | return nodes;
107 | }
108 |
109 | function getNode(
110 | nodes: DataNodes,
111 | property: PropertyKey,
112 | value?: any,
113 | equals: false | ((a: any, b: any) => boolean) = isEqual
114 | ): DataNode {
115 | if (nodes[property]) return nodes[property]!;
116 | return (nodes[property] = new Computation(value, null, {
117 | equals: equals,
118 | unobserved() {
119 | delete nodes[property];
120 | }
121 | }));
122 | }
123 |
124 | function proxyDescriptor(target: StoreNode, property: PropertyKey) {
125 | if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
126 | const desc = Reflect.getOwnPropertyDescriptor(target[STORE_VALUE], property);
127 | if (!desc || desc.get || !desc.configurable) return desc;
128 | delete desc.value;
129 | delete desc.writable;
130 | desc.get = () => target[STORE_VALUE][$PROXY][property];
131 | return desc;
132 | }
133 |
134 | function trackSelf(target: StoreNode, symbol: symbol = $TRACK) {
135 | getObserver() && getNode(getNodes(target, STORE_NODE), symbol, undefined, false).read();
136 | }
137 |
138 | function ownKeys(target: StoreNode) {
139 | trackSelf(target);
140 | return Reflect.ownKeys(target[STORE_VALUE]);
141 | }
142 |
143 | let Writing: Set