@esportsplus/reactivity 0.22.1 → 0.23.0

package/build/transformer/core/transforms/reactive-object.js

@@ -0,0 +1,155 @@
+import { uid } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+import { addMissingImports, applyReplacements } from './utilities.js';
+const CLASS_NAME_REGEX = /class (\w+)/;
+const EXTRA_IMPORTS = [
+    { module: '@esportsplus/reactivity/constants', specifier: 'REACTIVE_OBJECT' },
+    { module: '@esportsplus/reactivity/reactive/array', specifier: 'ReactiveArray' }
+];
+function analyzeProperty(prop, sourceFile) {
+    if (!ts.isPropertyAssignment(prop)) {
+        return null;
+    }
+    let key;
+    if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) {
+        key = prop.name.text;
+    }
+    else {
+        return null;
+    }
+    let value = prop.initializer, valueText = value.getText(sourceFile);
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
+        return { key, type: 'computed', valueText };
+    }
+    if (ts.isArrayLiteralExpression(value)) {
+        return { key, type: 'array', valueText };
+    }
+    return { key, type: 'signal', valueText };
+}
+function buildClassCode(className, properties) {
+    let accessors = [], disposeStatements = [], fields = [];
+    fields.push(`[REACTIVE_OBJECT] = true;`);
+    for (let i = 0, n = properties.length; i < n; i++) {
+        let { key, type, valueText } = properties[i];
+        if (type === 'signal') {
+            let param = uid('v');
+            fields.push(`#${key} = signal(${valueText});`);
+            accessors.push(`get ${key}() { return read(this.#${key}); }`);
+            accessors.push(`set ${key}(${param}) { set(this.#${key}, ${param}); }`);
+        }
+        else if (type === 'array') {
+            let elements = valueText.slice(1, -1);
+            fields.push(`${key} = new ReactiveArray(${elements});`);
+            disposeStatements.push(`this.${key}.dispose();`);
+        }
+        else if (type === 'computed') {
+            fields.push(`#${key}: Computed<unknown> | null = null;`);
+            accessors.push(`get ${key}() { return read(this.#${key} ??= computed(${valueText})); }`);
+            disposeStatements.push(`if (this.#${key}) dispose(this.#${key});`);
+        }
+    }
+    let disposeBody = disposeStatements.length > 0 ? disposeStatements.join('\n') : '';
+    return `
+        class ${className} {
+            ${fields.join('\n')}
+            ${accessors.join('\n')}
+
+            dispose() {
+                ${disposeBody}
+            }
+        }
+    `;
+}
+const transformReactiveObjects = (sourceFile, bindings) => {
+    let allNeededImports = new Set(), calls = [], code = sourceFile.getFullText(), hasReactiveImport = false, lastImportEnd = 0;
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            lastImportEnd = node.end;
+            if (ts.isStringLiteral(node.moduleSpecifier) &&
+                node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+                let clause = node.importClause;
+                if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                    let elements = clause.namedBindings.elements;
+                    for (let i = 0, n = elements.length; i < n; i++) {
+                        if (elements[i].name.text === 'reactive') {
+                            hasReactiveImport = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (hasReactiveImport &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'reactive') {
+            let arg = node.arguments[0];
+            if (arg && ts.isObjectLiteralExpression(arg)) {
+                let varName = null;
+                if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+                    varName = node.parent.name.text;
+                    bindings.set(varName, 'object');
+                }
+                let needsImports = new Set(), properties = [];
+                needsImports.add('REACTIVE_OBJECT');
+                let props = arg.properties;
+                for (let i = 0, n = props.length; i < n; i++) {
+                    let prop = props[i];
+                    if (ts.isSpreadAssignment(prop)) {
+                        return;
+                    }
+                    let analyzed = analyzeProperty(prop, sourceFile);
+                    if (!analyzed) {
+                        return;
+                    }
+                    properties.push(analyzed);
+                    if (analyzed.type === 'signal') {
+                        needsImports.add('read');
+                        needsImports.add('set');
+                        needsImports.add('signal');
+                    }
+                    else if (analyzed.type === 'array') {
+                        needsImports.add('ReactiveArray');
+                        if (varName) {
+                            bindings.set(`${varName}.${analyzed.key}`, 'array');
+                        }
+                    }
+                    else if (analyzed.type === 'computed') {
+                        needsImports.add('computed');
+                        needsImports.add('dispose');
+                        needsImports.add('read');
+                    }
+                }
+                needsImports.forEach(imp => allNeededImports.add(imp));
+                calls.push({
+                    end: node.end,
+                    generatedClass: buildClassCode(uid('ReactiveObject'), properties),
+                    needsImports,
+                    start: node.pos,
+                    varName
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (calls.length === 0) {
+        return code;
+    }
+    let replacements = [];
+    replacements.push({
+        end: lastImportEnd,
+        newText: code.substring(0, lastImportEnd) + '\n' + calls.map(c => c.generatedClass).join('\n') + '\n',
+        start: 0
+    });
+    for (let i = 0, n = calls.length; i < n; i++) {
+        let call = calls[i], classMatch = call.generatedClass.match(CLASS_NAME_REGEX);
+        replacements.push({
+            end: call.end,
+            newText: ` new ${classMatch ? classMatch[1] : 'ReactiveObject'}()`,
+            start: call.start
+        });
+    }
+    return addMissingImports(applyReplacements(code, replacements), allNeededImports, EXTRA_IMPORTS);
+};
+export { transformReactiveObjects };

package/build/transformer/core/transforms/reactive-primitives.d.ts

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

package/build/transformer/core/transforms/reactive-primitives.js

@@ -0,0 +1,325 @@
+import { uid } from '@esportsplus/typescript/transformer';
+import ts from 'typescript';
+import { addMissingImports, applyReplacements } from './utilities.js';
+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 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 isInComputedRange(ranges, start, end) {
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let r = ranges[i];
+        if (start >= r.start && end <= r.end) {
+            return true;
+        }
+    }
+    return false;
+}
+function isInScope(reference, binding) {
+    let current = reference;
+    while (current) {
+        if (current === binding.scope) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function classifyReactiveArg(arg) {
+    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
+        return 'computed';
+    }
+    if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
+        return null;
+    }
+    return 'signal';
+}
+function isInDeclarationInit(node) {
+    let parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node) {
+        return true;
+    }
+    return false;
+}
+function isReactiveReassignment(node) {
+    let parent = node.parent;
+    if (ts.isBinaryExpression(parent) &&
+        parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        parent.right === node &&
+        ts.isCallExpression(node) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === 'reactive') {
+        return true;
+    }
+    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 (op >= ts.SyntaxKind.PlusEqualsToken && op <= ts.SyntaxKind.CaretEqualsToken) {
+            return 'compound';
+        }
+        if (op === ts.SyntaxKind.AmpersandAmpersandEqualsToken ||
+            op === ts.SyntaxKind.BarBarEqualsToken ||
+            op === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+            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 getCompoundOperator(kind) {
+    if (kind === ts.SyntaxKind.PlusEqualsToken) {
+        return '+';
+    }
+    else if (kind === ts.SyntaxKind.MinusEqualsToken) {
+        return '-';
+    }
+    else if (kind === ts.SyntaxKind.AsteriskEqualsToken) {
+        return '*';
+    }
+    else if (kind === ts.SyntaxKind.SlashEqualsToken) {
+        return '/';
+    }
+    else if (kind === ts.SyntaxKind.PercentEqualsToken) {
+        return '%';
+    }
+    else if (kind === ts.SyntaxKind.AsteriskAsteriskEqualsToken) {
+        return '**';
+    }
+    else if (kind === ts.SyntaxKind.AmpersandEqualsToken) {
+        return '&';
+    }
+    else if (kind === ts.SyntaxKind.BarEqualsToken) {
+        return '|';
+    }
+    else if (kind === ts.SyntaxKind.CaretEqualsToken) {
+        return '^';
+    }
+    else if (kind === ts.SyntaxKind.LessThanLessThanEqualsToken) {
+        return '<<';
+    }
+    else if (kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken) {
+        return '>>';
+    }
+    else if (kind === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken) {
+        return '>>>';
+    }
+    else if (kind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
+        return '&&';
+    }
+    else if (kind === ts.SyntaxKind.BarBarEqualsToken) {
+        return '||';
+    }
+    else if (kind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+        return '??';
+    }
+    else {
+        return '+';
+    }
+}
+function transformComputedArg(arg, scopedBindings, sourceFile, neededImports) {
+    let argStart = arg.getStart(sourceFile), innerReplacements = [], text = arg.getText(sourceFile);
+    function visitArg(node) {
+        if (ts.isIdentifier(node)) {
+            if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+                ts.forEachChild(node, visitArg);
+                return;
+            }
+            if (ts.isCallExpression(node.parent) && node.parent.expression === node) {
+                ts.forEachChild(node, visitArg);
+                return;
+            }
+            let binding = findBinding(scopedBindings, node.text, node);
+            if (binding) {
+                neededImports.add('read');
+                innerReplacements.push({
+                    end: node.end - argStart,
+                    newText: `read(${node.text})`,
+                    start: node.getStart(sourceFile) - argStart
+                });
+            }
+        }
+        ts.forEachChild(node, visitArg);
+    }
+    visitArg(arg);
+    return applyReplacements(text, innerReplacements);
+}
+const transformReactivePrimitives = (sourceFile, bindings) => {
+    let code = sourceFile.getFullText(), computedArgRanges = [], hasReactiveImport = false, neededImports = new Set(), replacements = [], scopedBindings = [];
+    function visit(node) {
+        if (ts.isImportDeclaration(node) &&
+            ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+            let clause = node.importClause;
+            if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+                for (let i = 0, n = clause.namedBindings.elements.length; i < n; i++) {
+                    if (clause.namedBindings.elements[i].name.text === 'reactive') {
+                        hasReactiveImport = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (hasReactiveImport &&
+            ts.isCallExpression(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === 'reactive' &&
+            node.arguments.length > 0) {
+            let arg = node.arguments[0], classification = classifyReactiveArg(arg);
+            if (classification) {
+                let varName = null;
+                if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+                    varName = node.parent.name.text;
+                }
+                else if (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);
+                    scopedBindings.push({ name: varName, scope, type: classification });
+                    bindings.set(varName, classification);
+                }
+                if (classification === 'computed') {
+                    computedArgRanges.push({
+                        end: arg.end,
+                        start: arg.getStart(sourceFile)
+                    });
+                    let argText = transformComputedArg(arg, scopedBindings, sourceFile, neededImports);
+                    replacements.push({
+                        end: node.end,
+                        newText: `computed(${argText})`,
+                        start: node.pos
+                    });
+                    neededImports.add('computed');
+                }
+                else {
+                    let argText = arg.getText(sourceFile);
+                    replacements.push({
+                        end: node.end,
+                        newText: `signal(${argText})`,
+                        start: node.pos
+                    });
+                    neededImports.add('signal');
+                }
+            }
+        }
+        if (ts.isIdentifier(node) && !isInDeclarationInit(node.parent)) {
+            if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            let nodeStart = node.getStart(sourceFile);
+            let insideComputedArg = isInComputedRange(computedArgRanges, nodeStart, node.end);
+            if (insideComputedArg) {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            let binding = findBinding(scopedBindings, node.text, node), name = node.text;
+            if (binding) {
+                if (!isReactiveReassignment(node.parent) &&
+                    !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
+                    let writeCtx = isWriteContext(node);
+                    if (writeCtx) {
+                        if (binding.type !== 'computed') {
+                            neededImports.add('set');
+                            let parent = node.parent;
+                            if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
+                                let valueText = parent.right.getText(sourceFile);
+                                replacements.push({
+                                    end: parent.end,
+                                    newText: `set(${name}, ${valueText})`,
+                                    start: parent.pos
+                                });
+                            }
+                            else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
+                                let op = getCompoundOperator(parent.operatorToken.kind), valueText = parent.right.getText(sourceFile);
+                                replacements.push({
+                                    end: parent.end,
+                                    newText: `set(${name}, ${name}.value ${op} ${valueText})`,
+                                    start: parent.pos
+                                });
+                            }
+                            else if (writeCtx === 'increment') {
+                                let isPrefix = ts.isPrefixUnaryExpression(parent), op = parent.operator, delta = op === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
+                                if (ts.isExpressionStatement(parent.parent)) {
+                                    replacements.push({
+                                        end: parent.end,
+                                        newText: `set(${name}, ${name}.value ${delta})`,
+                                        start: parent.pos
+                                    });
+                                }
+                                else if (isPrefix) {
+                                    replacements.push({
+                                        end: parent.end,
+                                        newText: `(set(${name}, ${name}.value ${delta}), ${name}.value)`,
+                                        start: parent.pos
+                                    });
+                                }
+                                else {
+                                    let tmp = uid('tmp');
+                                    replacements.push({
+                                        end: parent.end,
+                                        newText: `((${tmp}) => (set(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                                        start: parent.pos
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        neededImports.add('read');
+                        replacements.push({
+                            end: node.end,
+                            newText: `read(${name})`,
+                            start: node.pos
+                        });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    if (replacements.length === 0) {
+        return code;
+    }
+    let result = applyReplacements(code, replacements);
+    if (neededImports.size > 0) {
+        result = addMissingImports(result, neededImports);
+    }
+    return result;
+};
+export { transformReactivePrimitives };

package/build/transformer/core/transforms/utilities.d.ts

@@ -0,0 +1,9 @@
+import type { Replacement } from '@esportsplus/typescript/transformer';
+import { applyReplacements } from '@esportsplus/typescript/transformer';
+type ExtraImport = {
+    module: string;
+    specifier: string;
+};
+declare const addMissingImports: (code: string, needed: Set<string>, extraImports?: ExtraImport[]) => string;
+export { addMissingImports, applyReplacements };
+export type { ExtraImport, Replacement };

package/build/transformer/core/transforms/utilities.js

@@ -0,0 +1,57 @@
+import { applyReplacements } from '@esportsplus/typescript/transformer';
+const BRACES_CONTENT_REGEX = /\{([^}]*)\}/;
+const REACTIVITY_IMPORT_REGEX = /(import\s*\{[^}]*\}\s*from\s*['"]@esportsplus\/reactivity['"])/;
+const addMissingImports = (code, needed, extraImports) => {
+    let reactivityImportMatch = code.match(REACTIVITY_IMPORT_REGEX);
+    if (!reactivityImportMatch) {
+        return code;
+    }
+    let bracesMatch = reactivityImportMatch[1].match(BRACES_CONTENT_REGEX), existing = new Set(), existingImport = reactivityImportMatch[1], extraSpecifiers = new Set(), toAdd = [];
+    if (bracesMatch?.[1]) {
+        let parts = bracesMatch[1].split(',');
+        for (let i = 0, n = parts.length; i < n; i++) {
+            let trimmed = parts[i].trim();
+            if (trimmed) {
+                existing.add(trimmed);
+            }
+        }
+    }
+    if (extraImports) {
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            extraSpecifiers.add(extraImports[i].specifier);
+        }
+    }
+    for (let imp of needed) {
+        if (!extraSpecifiers.has(imp) && !existing.has(imp)) {
+            toAdd.push(imp);
+        }
+    }
+    if (toAdd.length > 0) {
+        let combined = [];
+        for (let item of existing) {
+            if (item) {
+                combined.push(item);
+            }
+        }
+        for (let i = 0, n = toAdd.length; i < n; i++) {
+            if (toAdd[i]) {
+                combined.push(toAdd[i]);
+            }
+        }
+        combined.sort();
+        code = code.replace(existingImport, existingImport.replace(BRACES_CONTENT_REGEX, `{ ${combined.join(', ')} }`));
+    }
+    if (extraImports) {
+        for (let i = 0, n = extraImports.length; i < n; i++) {
+            let extra = extraImports[i];
+            if (needed.has(extra.specifier) && !code.includes(extra.module)) {
+                let insertPos = code.indexOf('import');
+                code = code.substring(0, insertPos) +
+                    `import { ${extra.specifier} } from '${extra.module}';\n` +
+                    code.substring(insertPos);
+            }
+        }
+    }
+    return code;
+};
+export { addMissingImports, applyReplacements };

package/build/transformer/plugins/esbuild.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'esbuild';
+import type { TransformOptions } from '../../types.js';
+declare const _default: (options?: TransformOptions) => Plugin;
+export default _default;
+export type { TransformOptions as PluginOptions };

package/build/transformer/plugins/esbuild.js

@@ -0,0 +1,30 @@
+import { mightNeedTransform, transform } from '../../transformer/core/index.js';
+import fs from 'fs';
+import ts from 'typescript';
+export default (options) => {
+    return {
+        name: '@esportsplus/reactivity/plugin-esbuild',
+        setup(build) {
+            build.onLoad({ filter: /\.[tj]sx?$/ }, async (args) => {
+                let code = await fs.promises.readFile(args.path, 'utf8');
+                if (!mightNeedTransform(code)) {
+                    return null;
+                }
+                try {
+                    let sourceFile = ts.createSourceFile(args.path, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile, options);
+                    if (!result.transformed) {
+                        return null;
+                    }
+                    return {
+                        contents: result.code,
+                        loader: args.path.endsWith('x') ? 'tsx' : 'ts'
+                    };
+                }
+                catch (error) {
+                    console.error(`@esportsplus/reactivity: Error transforming ${args.path}:`, error);
+                    return null;
+                }
+            });
+        }
+    };
+};

package/build/transformer/plugins/tsc.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+declare const _default: (_program: ts.Program) => ts.TransformerFactory<ts.SourceFile>;
+export default _default;

package/build/transformer/plugins/tsc.js

@@ -0,0 +1,4 @@
+import { createTransformer } from '../../transformer/core/index.js';
+export default (_program) => {
+    return createTransformer();
+};

package/build/transformer/plugins/vite.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'vite';
+import type { TransformOptions } from '../../types.js';
+declare const _default: (options?: TransformOptions) => Plugin;
+export default _default;
+export type { TransformOptions as PluginOptions };

package/build/transformer/plugins/vite.js

@@ -0,0 +1,28 @@
+import { mightNeedTransform, transform } from '../../transformer/core/index.js';
+import ts from 'typescript';
+const TRANSFORM_PATTERN = /\.[tj]sx?$/;
+export default (options) => {
+    return {
+        enforce: 'pre',
+        name: '@esportsplus/reactivity/plugin-vite',
+        transform(code, id) {
+            if (!TRANSFORM_PATTERN.test(id) || id.includes('node_modules')) {
+                return null;
+            }
+            if (!mightNeedTransform(code)) {
+                return null;
+            }
+            try {
+                let sourceFile = ts.createSourceFile(id, code, ts.ScriptTarget.Latest, true), result = transform(sourceFile, options);
+                if (!result.transformed) {
+                    return null;
+                }
+                return { code: result.code, map: null };
+            }
+            catch (error) {
+                console.error(`@esportsplus/reactivity: Error transforming ${id}:`, error);
+                return null;
+            }
+        }
+    };
+};

package/build/types.d.ts

@@ -1,6 +1,8 @@
 import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-import { ReactiveArray } from './reactive/array.js';
-import { ReactiveObject } from './reactive/object.js';
+import { ReactiveArray, ReactiveObject } from './reactive/index.js';
+import ts from 'typescript';
+type BindingType = 'array' | 'computed' | 'object' | 'signal';
+type Bindings = Map<string, BindingType>;
 interface Computed<T> {
     cleanup: VoidFunction | VoidFunction[] | null;
     deps: Link | null;
@@ -17,10 +19,10 @@ interface Computed<T> {
 }
 interface Link {
     dep: Signal<unknown> | Computed<unknown>;
-    sub: Computed<unknown>;
     nextDep: Link | null;
     nextSub: Link | null;
     prevSub: Link | null;
+    sub: Computed<unknown>;
     version: number;
 }
 type Signal<T> = {
@@ -29,4 +31,12 @@ type Signal<T> = {
     type: typeof SIGNAL;
     value: T;
 };
-export type { Computed, Link, Signal, ReactiveArray, ReactiveObject };
+interface TransformOptions {
+    autoDispose?: boolean;
+}
+interface TransformResult {
+    code: string;
+    sourceFile: ts.SourceFile;
+    transformed: boolean;
+}
+export type { BindingType, Bindings, Computed, Link, ReactiveArray, ReactiveObject, Signal, TransformOptions, TransformResult };