@esportsplus/reactivity 0.23.0 → 0.23.2

package/build/transformer/core/transforms/auto-dispose.js

@@ -1,116 +0,0 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import ts from 'typescript';
-import { applyReplacements } from './utilities.js';
-const TRAILING_SEMICOLON = /;$/;
-function visitFunctionBody(body, parentBody) {
-    let disposables = [], effectsToCapture = [], returnStatement = null;
-    function visit(n) {
-        if (ts.isVariableDeclaration(n) &&
-            ts.isIdentifier(n.name) &&
-            n.initializer &&
-            ts.isCallExpression(n.initializer) &&
-            ts.isIdentifier(n.initializer.expression) &&
-            n.initializer.expression.text === 'reactive') {
-            disposables.push({ name: n.name.text, type: 'reactive' });
-        }
-        if (ts.isCallExpression(n) &&
-            ts.isIdentifier(n.expression) &&
-            n.expression.text === 'effect') {
-            if (ts.isVariableDeclaration(n.parent) && ts.isIdentifier(n.parent.name)) {
-                disposables.push({ name: n.parent.name.text, type: 'effect' });
-            }
-            else if (ts.isExpressionStatement(n.parent)) {
-                let name = uid('effect');
-                effectsToCapture.push({
-                    end: n.parent.end,
-                    name,
-                    start: n.parent.pos
-                });
-                disposables.push({ name, type: 'effect' });
-            }
-        }
-        if (ts.isReturnStatement(n) &&
-            n.expression &&
-            (ts.isArrowFunction(n.expression) || ts.isFunctionExpression(n.expression)) &&
-            n.parent === parentBody) {
-            returnStatement = n;
-        }
-        ts.forEachChild(n, visit);
-    }
-    visit(body);
-    return { disposables, effectsToCapture, returnStatement };
-}
-function processFunction(node, sourceFile, edits) {
-    if (!node.body || !ts.isBlock(node.body)) {
-        return;
-    }
-    let result = visitFunctionBody(node.body, node.body), disposables = result.disposables, effectsToCapture = result.effectsToCapture, returnStatement = result.returnStatement;
-    if (disposables.length === 0 || !returnStatement || !returnStatement.expression) {
-        return;
-    }
-    let cleanupFn = returnStatement.expression;
-    if (!cleanupFn.body) {
-        return;
-    }
-    let disposeStatements = [];
-    for (let i = disposables.length - 1; i >= 0; i--) {
-        let d = disposables[i];
-        if (d.type === 'reactive') {
-            disposeStatements.push(`${d.name}.dispose();`);
-        }
-        else {
-            disposeStatements.push(`${d.name}();`);
-        }
-    }
-    let disposeCode = disposeStatements.join('\n');
-    if (ts.isBlock(cleanupFn.body)) {
-        edits.push({
-            cleanupBodyEnd: cleanupFn.body.statements[0]?.pos ?? cleanupFn.body.end - 1,
-            cleanupBodyStart: cleanupFn.body.pos + 1,
-            disposeCode,
-            effectsToCapture
-        });
-    }
-    else {
-        edits.push({
-            cleanupBodyEnd: cleanupFn.body.end,
-            cleanupBodyStart: cleanupFn.body.pos,
-            disposeCode: `{ ${disposeCode}\n return ${cleanupFn.body.getText(sourceFile)}; }`,
-            effectsToCapture
-        });
-    }
-}
-const injectAutoDispose = (sourceFile) => {
-    let code = sourceFile.getFullText(), edits = [];
-    function visit(node) {
-        if (ts.isFunctionDeclaration(node) ||
-            ts.isFunctionExpression(node) ||
-            ts.isArrowFunction(node)) {
-            processFunction(node, sourceFile, edits);
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    if (edits.length === 0) {
-        return code;
-    }
-    let replacements = [];
-    for (let i = 0, n = edits.length; i < n; i++) {
-        let edit = edits[i], effects = edit.effectsToCapture;
-        for (let j = 0, m = effects.length; j < m; j++) {
-            let effect = effects[j], original = code.substring(effect.start, effect.end).trim();
-            replacements.push({
-                end: effect.end,
-                newText: `const ${effect.name} = ${original.replace(TRAILING_SEMICOLON, '')}`,
-                start: effect.start
-            });
-        }
-        replacements.push({
-            end: edit.cleanupBodyEnd,
-            newText: `\n${edit.disposeCode}`,
-            start: edit.cleanupBodyStart
-        });
-    }
-    return applyReplacements(code, replacements);
-};
-export { injectAutoDispose };

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

@@ -1,89 +0,0 @@
-import ts from 'typescript';
-import { applyReplacements } from './utilities.js';
-function getPropertyPath(node) {
-    let current = node, parts = [];
-    while (ts.isPropertyAccessExpression(current)) {
-        parts.unshift(current.name.text);
-        current = current.expression;
-    }
-    if (ts.isIdentifier(current)) {
-        parts.unshift(current.text);
-        return parts.join('.');
-    }
-    return null;
-}
-function getExpressionName(node) {
-    if (ts.isIdentifier(node)) {
-        return node.text;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return getPropertyPath(node);
-    }
-    return null;
-}
-function isAssignmentTarget(node) {
-    let parent = node.parent;
-    if ((ts.isBinaryExpression(parent) && parent.left === node) ||
-        ts.isPostfixUnaryExpression(parent) ||
-        ts.isPrefixUnaryExpression(parent)) {
-        return true;
-    }
-    return false;
-}
-const transformReactiveArrays = (sourceFile, bindings) => {
-    let code = sourceFile.getFullText(), replacements = [];
-    function visit(node) {
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
-            if (ts.isIdentifier(node.initializer) && bindings.get(node.initializer.text) === 'array') {
-                bindings.set(node.name.text, 'array');
-            }
-            if (ts.isPropertyAccessExpression(node.initializer)) {
-                let path = getPropertyPath(node.initializer);
-                if (path && bindings.get(path) === 'array') {
-                    bindings.set(node.name.text, 'array');
-                }
-            }
-        }
-        if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) && node.parameters) {
-            for (let i = 0, n = node.parameters.length; i < n; i++) {
-                let param = node.parameters[i];
-                if ((ts.isIdentifier(param.name) && param.type) &&
-                    ts.isTypeReferenceNode(param.type) &&
-                    ts.isIdentifier(param.type.typeName) &&
-                    param.type.typeName.text === 'ReactiveArray') {
-                    bindings.set(param.name.text, 'array');
-                }
-            }
-        }
-        if (ts.isPropertyAccessExpression(node) &&
-            node.name.text === 'length' &&
-            !isAssignmentTarget(node)) {
-            let objName = getExpressionName(node.expression);
-            if (objName && bindings.get(objName) === 'array') {
-                let objText = node.expression.getText(sourceFile);
-                replacements.push({
-                    end: node.end,
-                    newText: `${objText}.$length()`,
-                    start: node.pos
-                });
-            }
-        }
-        if (ts.isBinaryExpression(node) &&
-            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-            ts.isElementAccessExpression(node.left)) {
-            let elemAccess = node.left, objName = getExpressionName(elemAccess.expression);
-            if (objName && bindings.get(objName) === 'array') {
-                let indexText = elemAccess.argumentExpression.getText(sourceFile), objText = elemAccess.expression.getText(sourceFile), valueText = node.right.getText(sourceFile);
-                replacements.push({
-                    end: node.end,
-                    newText: `${objText}.$set(${indexText}, ${valueText})`,
-                    start: node.pos
-                });
-            }
-        }
-        ts.forEachChild(node, visit);
-    }
-    visit(sourceFile);
-    return applyReplacements(code, replacements);
-};
-export { transformReactiveArrays };

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

@@ -1,155 +0,0 @@
-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.js

@@ -1,325 +0,0 @@
-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 };