@esportsplus/reactivity 0.27.0 → 0.27.3

package/src/reactive/object.ts

@@ -0,0 +1,126 @@
+import { defineProperty, isArray, isPromise } from '@esportsplus/utilities';
+import { computed, dispose, effect, read, root, signal, write } from '~/system';
+import { Computed, Signal } from '~/types';
+import { COMPUTED, REACTIVE_ARRAY, REACTIVE_OBJECT, SIGNAL } from '~/constants';
+import { ReactiveArray } from './array';
+
+
+class ReactiveObject<T extends Record<PropertyKey, unknown>> {
+    protected disposers: VoidFunction[] | null = null;
+
+
+    constructor(data: T | null) {
+        if (data == null) {
+            return;
+        }
+
+        for (let key in data) {
+            let value = data[key as keyof T],
+                type = typeof value;
+
+            if (type === 'function') {
+                let node = this[COMPUTED]( value as () => T[keyof T] );
+
+                defineProperty(this, key, {
+                    enumerable: true,
+                    get: () => read(node)
+                });
+
+                continue;
+            }
+
+            if (value == null || type !== 'object') {
+                // Skip isArray when possible
+            }
+            else if (isArray(value)) {
+                defineProperty(this, key, {
+                    enumerable: true,
+                    value: this[REACTIVE_ARRAY](value)
+                });
+
+                continue;
+            }
+
+            let node = signal(value);
+
+            defineProperty(this, key, {
+                enumerable: true,
+                get() {
+                    return read(node);
+                },
+                set(v: typeof value) {
+                    write(node, v);
+                }
+            });
+        }
+    }
+
+
+    protected [REACTIVE_ARRAY]<U>(value: U[]): ReactiveArray<U> {
+        let node = new ReactiveArray(...value);
+
+        (this.disposers ??= []).push( () => node.dispose() );
+
+        return node;
+    }
+
+    protected [COMPUTED]<T extends Computed<ReturnType<T>>['fn']>(value: T) {
+        return root(() => {
+            let node: Computed<ReturnType<T>> | Signal<ReturnType<T> | undefined> = computed(value);
+
+            if (isPromise(node.value)) {
+                let factory = node,
+                    version = 0;
+
+                node = signal<ReturnType<T> | undefined>(undefined);
+
+                (this.disposers ??= []).push(
+                    effect(() => {
+                        let id = ++version;
+
+                        (read(factory) as Promise<ReturnType<T>>).then((v) => {
+                            if (id !== version) {
+                                return;
+                            }
+
+                            write(node as Signal<typeof v>, v);
+                        });
+                    })
+                )
+            }
+            else {
+                (this.disposers ??= []).push(() => dispose(node as Computed<ReturnType<T>>));
+            }
+
+            return node;
+        });
+    }
+
+    protected [SIGNAL]<T>(value: T) {
+        return signal(value);
+    }
+
+
+    dispose() {
+        let disposers = this.disposers,
+            disposer;
+
+        if (!disposers) {
+            return;
+        }
+
+        while (disposer = disposers.pop()) {
+            disposer();
+        }
+    }
+}
+
+Object.defineProperty(ReactiveObject.prototype, REACTIVE_OBJECT, { value: true });
+
+
+const isReactiveObject = (value: any): value is ReactiveObject<any> => {
+    return typeof value === 'object' && value !== null && value[REACTIVE_OBJECT] === true;
+};
+
+
+export { isReactiveObject, ReactiveObject };

package/src/types.ts

@@ -43,9 +43,9 @@ type Reactive<T> = T extends (...args: unknown[]) => Promise<infer R>
     : T extends (...args: any[]) => infer R
         ? R & { readonly [READONLY]: true }
         : T extends (infer U)[]
-            ? U[] & Pick<ReactiveArray<U>, 'clear' | 'on' | 'once'>
+            ? U[] & Pick<ReactiveArray<U>, 'clear' | 'dispose' | 'on' | 'once'>
             : T extends Record<PropertyKey, unknown>
-                ? { [K in keyof T]: T[K] } & { dispose: VoidFunction }
+                ? { [K in keyof T]: Reactive<T[K]>; } & { dispose: VoidFunction }
                 : T;
 
 type Signal<T> = {

package/test/debug.ts

@@ -0,0 +1,7 @@
+import { reactive } from '@esportsplus/reactivity';
+
+let value = reactive({
+    hey: () => 'sadasd'
+});
+
+console.log(value.hey);

package/test/vite.config.ts

@@ -1,6 +1,6 @@
 import { resolve } from 'path';
 import { defineConfig } from 'vite';
-import reactivity from '../build/transformer/plugins/vite.js';
+import reactivity from '../build/compiler/plugins/vite.js';
 
 
 export default defineConfig({
@@ -8,6 +8,7 @@ export default defineConfig({
         lib: {
             entry: {
                 arrays: resolve(__dirname, 'arrays.ts'),
+                debug: resolve(__dirname, 'debug.ts'),
                 effects: resolve(__dirname, 'effects.ts'),
                 index: resolve(__dirname, 'index.ts'),
                 nested: resolve(__dirname, 'nested.ts'),

package/build/compiler/primitives.d.ts

@@ -1,4 +0,0 @@
-import { ts } from '@esportsplus/typescript';
-import type { Bindings } from '../types.js';
-declare const _default: (sourceFile: ts.SourceFile, bindings: Bindings, ns: string, checker?: ts.TypeChecker) => string;
-export default _default;

package/build/compiler/primitives.js

@@ -1,258 +0,0 @@
-import { ts } from '@esportsplus/typescript';
-import { ast, code as c, imports } from '@esportsplus/typescript/compiler';
-import { COMPILER_ENTRYPOINT, COMPILER_TYPES, PACKAGE } from '../constants.js';
-const COMPOUND_OPERATORS = new Map([
-    [ts.SyntaxKind.AmpersandAmpersandEqualsToken, '&&'],
-    [ts.SyntaxKind.AmpersandEqualsToken, '&'],
-    [ts.SyntaxKind.AsteriskAsteriskEqualsToken, '**'],
-    [ts.SyntaxKind.AsteriskEqualsToken, '*'],
-    [ts.SyntaxKind.BarBarEqualsToken, '||'],
-    [ts.SyntaxKind.BarEqualsToken, '|'],
-    [ts.SyntaxKind.CaretEqualsToken, '^'],
-    [ts.SyntaxKind.GreaterThanGreaterThanEqualsToken, '>>'],
-    [ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, '>>>'],
-    [ts.SyntaxKind.LessThanLessThanEqualsToken, '<<'],
-    [ts.SyntaxKind.MinusEqualsToken, '-'],
-    [ts.SyntaxKind.PercentEqualsToken, '%'],
-    [ts.SyntaxKind.PlusEqualsToken, '+'],
-    [ts.SyntaxKind.QuestionQuestionEqualsToken, '??'],
-    [ts.SyntaxKind.SlashEqualsToken, '/']
-]);
-function findBinding(bindings, name, node) {
-    for (let i = 0, n = bindings.length; i < n; i++) {
-        let b = bindings[i];
-        if (b.name === name && isInScope(node, b)) {
-            return b;
-        }
-    }
-    return undefined;
-}
-function findEnclosingScope(node) {
-    let current = node.parent;
-    while (current) {
-        if (ts.isBlock(current) ||
-            ts.isSourceFile(current) ||
-            ts.isFunctionDeclaration(current) ||
-            ts.isFunctionExpression(current) ||
-            ts.isArrowFunction(current) ||
-            ts.isForStatement(current) ||
-            ts.isForInStatement(current) ||
-            ts.isForOfStatement(current)) {
-            return current;
-        }
-        current = current.parent;
-    }
-    return node.getSourceFile();
-}
-function isInDeclarationInit(node) {
-    let parent = node.parent;
-    return ts.isVariableDeclaration(parent) && parent.initializer === node;
-}
-function isInScope(reference, binding) {
-    let current = reference;
-    while (current) {
-        if (current === binding.scope) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
-}
-function isReactiveCall(node, checker) {
-    if (!ts.isIdentifier(node.expression)) {
-        return false;
-    }
-    if (node.expression.text !== COMPILER_ENTRYPOINT) {
-        return false;
-    }
-    return imports.isFromPackage(node.expression, PACKAGE, checker);
-}
-function isReactiveReassignment(node, checker) {
-    let parent = node.parent;
-    if (ts.isBinaryExpression(parent) &&
-        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        parent.right === node &&
-        ts.isCallExpression(node)) {
-        return isReactiveCall(node, checker);
-    }
-    return false;
-}
-function isWriteContext(node) {
-    let parent = node.parent;
-    if (ts.isBinaryExpression(parent) && parent.left === node) {
-        let op = parent.operatorToken.kind;
-        if (op === ts.SyntaxKind.EqualsToken) {
-            return 'simple';
-        }
-        if (COMPOUND_OPERATORS.has(op)) {
-            return 'compound';
-        }
-    }
-    if (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent)) {
-        let op = parent.operator;
-        if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
-            return 'increment';
-        }
-    }
-    return false;
-}
-function visit(ctx, node) {
-    if (ts.isCallExpression(node) &&
-        node.arguments.length > 0 &&
-        isReactiveCall(node, ctx.checker)) {
-        let arg = node.arguments[0], classification = COMPILER_TYPES.Signal;
-        if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-            classification = COMPILER_TYPES.Computed;
-        }
-        else if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
-            classification = null;
-        }
-        if (classification) {
-            let varName = null;
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                varName = node.parent.name.text;
-            }
-            else if (node.parent &&
-                ts.isBinaryExpression(node.parent) &&
-                node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-                ts.isIdentifier(node.parent.left)) {
-                varName = node.parent.left.text;
-            }
-            if (varName) {
-                let scope = findEnclosingScope(node);
-                ctx.scopedBindings.push({ name: varName, scope, type: classification });
-                ctx.bindings.set(varName, classification);
-            }
-            if (classification === COMPILER_TYPES.Computed) {
-                let argStart = arg.getStart(ctx.sourceFile);
-                ctx.computedArgRanges.push({ end: arg.end, start: argStart });
-                let argCtx = {
-                    argStart,
-                    innerReplacements: [],
-                    ns: ctx.ns,
-                    scopedBindings: ctx.scopedBindings,
-                    sourceFile: ctx.sourceFile
-                };
-                visitArg(argCtx, arg);
-                let argText = c.replace(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
-                ctx.replacements.push({
-                    end: node.end,
-                    newText: `${ctx.ns}.computed(${argText})`,
-                    start: node.pos
-                });
-            }
-            else {
-                ctx.replacements.push({
-                    end: node.end,
-                    newText: `${ctx.ns}.signal(${arg.getText(ctx.sourceFile)})`,
-                    start: node.pos
-                });
-            }
-        }
-    }
-    if (ts.isIdentifier(node) && node.parent && !isInDeclarationInit(node.parent)) {
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-            ts.forEachChild(node, n => visit(ctx, n));
-            return;
-        }
-        let nodeStart = node.getStart(ctx.sourceFile);
-        if (ast.inRange(ctx.computedArgRanges, nodeStart, node.end)) {
-            ts.forEachChild(node, n => visit(ctx, n));
-            return;
-        }
-        let binding = findBinding(ctx.scopedBindings, node.text, node), name = node.text;
-        if (binding && node.parent) {
-            if (!isReactiveReassignment(node.parent, ctx.checker) &&
-                !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
-                let writeCtx = isWriteContext(node);
-                if (writeCtx) {
-                    if (binding.type !== COMPILER_TYPES.Computed) {
-                        let parent = node.parent;
-                        if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
-                            ctx.replacements.push({
-                                end: parent.end,
-                                newText: `${ctx.ns}.write(${name}, ${parent.right.getText(ctx.sourceFile)})`,
-                                start: parent.pos
-                            });
-                        }
-                        else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
-                            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+';
-                            ctx.replacements.push({
-                                end: parent.end,
-                                newText: `${ctx.ns}.write(${name}, ${name}.value ${op} ${parent.right.getText(ctx.sourceFile)})`,
-                                start: parent.pos
-                            });
-                        }
-                        else if (writeCtx === 'increment') {
-                            let delta = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1', isPrefix = ts.isPrefixUnaryExpression(parent);
-                            if (ts.isExpressionStatement(parent.parent)) {
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `${ctx.ns}.write(${name}, ${name}.value ${delta})`,
-                                    start: parent.pos
-                                });
-                            }
-                            else if (isPrefix) {
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `(${ctx.ns}.write(${name}, ${name}.value ${delta}), ${name}.value)`,
-                                    start: parent.pos
-                                });
-                            }
-                            else {
-                                let tmp = `_t${ctx.tmpCounter++}`;
-                                ctx.replacements.push({
-                                    end: parent.end,
-                                    newText: `((${tmp}) => (${ctx.ns}.write(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
-                                    start: parent.pos
-                                });
-                            }
-                        }
-                    }
-                }
-                else {
-                    ctx.replacements.push({
-                        end: node.end,
-                        newText: `${ctx.ns}.read(${name})`,
-                        start: node.pos
-                    });
-                }
-            }
-        }
-    }
-    ts.forEachChild(node, n => visit(ctx, n));
-}
-function visitArg(ctx, node) {
-    if (ts.isIdentifier(node) && node.parent) {
-        if ((ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) ||
-            (ts.isCallExpression(node.parent) && node.parent.expression === node)) {
-            ts.forEachChild(node, n => visitArg(ctx, n));
-            return;
-        }
-        if (findBinding(ctx.scopedBindings, node.text, node)) {
-            ctx.innerReplacements.push({
-                end: node.end - ctx.argStart,
-                newText: `${ctx.ns}.read(${node.text})`,
-                start: node.getStart(ctx.sourceFile) - ctx.argStart
-            });
-        }
-    }
-    ts.forEachChild(node, n => visitArg(ctx, n));
-}
-export default (sourceFile, bindings, ns, checker) => {
-    let code = sourceFile.getFullText(), ctx = {
-        bindings,
-        checker,
-        computedArgRanges: [],
-        ns,
-        replacements: [],
-        scopedBindings: [],
-        sourceFile,
-        tmpCounter: 0
-    };
-    visit(ctx, sourceFile);
-    if (ctx.replacements.length === 0) {
-        return code;
-    }
-    return c.replace(code, ctx.replacements);
-};