@esportsplus/reactivity 0.25.2 → 0.25.4

package/build/transformer/transforms/object.js

@@ -1,11 +1,6 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import { addMissingImports, applyReplacements } from './utilities.js';
 import { ts } from '@esportsplus/typescript';
-const CLASS_NAME_REGEX = /class (\w+)/;
-const EXTRA_IMPORTS = [
-    { module: '@esportsplus/reactivity/constants', specifier: 'REACTIVE_OBJECT' },
-    { module: '@esportsplus/reactivity/reactive/array', specifier: 'ReactiveArray' }
-];
+import { code as c } from '@esportsplus/typescript/transformer';
+import { COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -19,33 +14,39 @@ function analyzeProperty(prop, sourceFile) {
     }
     let value = prop.initializer, valueText = value.getText(sourceFile);
     if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-        return { key, type: 'computed', valueText };
+        return { key, type: COMPILATION_TYPE_COMPUTED, valueText };
     }
     if (ts.isArrayLiteralExpression(value)) {
-        return { key, type: 'array', valueText };
+        let elements = value.elements, elementsText = '';
+        for (let i = 0, n = elements.length; i < n; i++) {
+            if (i > 0) {
+                elementsText += ', ';
+            }
+            elementsText += elements[i].getText(sourceFile);
+        }
+        return { key, type: COMPILATION_TYPE_ARRAY, valueText: elementsText };
     }
-    return { key, type: 'signal', valueText };
+    return { key, type: COMPILATION_TYPE_SIGNAL, valueText };
 }
-function buildClassCode(className, properties) {
-    let accessors = [], disposeStatements = [], fields = [];
-    fields.push(`[REACTIVE_OBJECT] = true;`);
+function buildClassCode(className, properties, ns) {
+    let accessors = [], disposeStatements = [], fields = [], paramCounter = 0;
+    fields.push(`[${ns}.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}); }`);
+        if (type === COMPILATION_TYPE_SIGNAL) {
+            let param = `_v${paramCounter++}`;
+            fields.push(`#${key} = ${ns}.signal(${valueText});`);
+            accessors.push(`get ${key}() { return ${ns}.read(this.#${key}); }`);
+            accessors.push(`set ${key}(${param}) { ${ns}.write(this.#${key}, ${param}); }`);
         }
-        else if (type === 'array') {
-            let elements = valueText.slice(1, -1);
-            fields.push(`${key} = new ReactiveArray(${elements});`);
+        else if (type === COMPILATION_TYPE_ARRAY) {
+            fields.push(`${key} = new ${ns}.ReactiveArray(${valueText});`);
             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});`);
+        else if (type === COMPILATION_TYPE_COMPUTED) {
+            fields.push(`#${key} = null;`);
+            accessors.push(`get ${key}() { return ${ns}.read(this.#${key} ??= ${ns}.computed(${valueText})); }`);
+            disposeStatements.push(`if (this.#${key}) ${ns}.dispose(this.#${key});`);
         }
     }
     return `
@@ -63,7 +64,7 @@ function visit(ctx, node) {
     if (ts.isImportDeclaration(node)) {
         ctx.lastImportEnd = node.end;
         if (ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+            node.moduleSpecifier.text.includes(PACKAGE)) {
             let clause = node.importClause;
             if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
                 let elements = clause.namedBindings.elements;
@@ -82,14 +83,11 @@ function visit(ctx, node) {
         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)) {
+            let properties = [], props = arg.properties, varName = null;
+            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
                 ctx.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)) {
@@ -102,28 +100,14 @@ function visit(ctx, node) {
                     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) {
-                        ctx.bindings.set(`${varName}.${analyzed.key}`, 'array');
-                    }
-                }
-                else if (analyzed.type === 'computed') {
-                    needsImports.add('computed');
-                    needsImports.add('dispose');
-                    needsImports.add('read');
+                if (analyzed.type === COMPILATION_TYPE_ARRAY && varName) {
+                    ctx.bindings.set(`${varName}.${analyzed.key}`, COMPILATION_TYPE_ARRAY);
                 }
             }
-            needsImports.forEach(imp => ctx.allNeededImports.add(imp));
             ctx.calls.push({
+                className: `_RO${ctx.classCounter++}`,
                 end: node.end,
-                generatedClass: buildClassCode(uid('ReactiveObject'), properties),
-                needsImports,
+                properties,
                 start: node.pos,
                 varName
             });
@@ -131,33 +115,33 @@ function visit(ctx, node) {
     }
     ts.forEachChild(node, n => visit(ctx, n));
 }
-const transformReactiveObjects = (sourceFile, bindings) => {
+export default (sourceFile, bindings, ns) => {
     let code = sourceFile.getFullText(), ctx = {
-        allNeededImports: new Set(),
         bindings,
         calls: [],
+        classCounter: 0,
         hasReactiveImport: false,
         lastImportEnd: 0,
+        ns,
         sourceFile
     };
     visit(ctx, sourceFile);
     if (ctx.calls.length === 0) {
         return code;
     }
-    let replacements = [];
+    let classes = ctx.calls.map(c => buildClassCode(c.className, c.properties, ns)).join('\n'), replacements = [];
     replacements.push({
         end: ctx.lastImportEnd,
-        newText: code.substring(0, ctx.lastImportEnd) + '\n' + ctx.calls.map(c => c.generatedClass).join('\n') + '\n',
+        newText: code.substring(0, ctx.lastImportEnd) + '\n' + classes + '\n',
         start: 0
     });
     for (let i = 0, n = ctx.calls.length; i < n; i++) {
-        let call = ctx.calls[i], classMatch = call.generatedClass.match(CLASS_NAME_REGEX);
+        let call = ctx.calls[i];
         replacements.push({
             end: call.end,
-            newText: ` new ${classMatch ? classMatch[1] : 'ReactiveObject'}()`,
+            newText: ` new ${call.className}()`,
             start: call.start
         });
     }
-    return addMissingImports(applyReplacements(code, replacements), ctx.allNeededImports, EXTRA_IMPORTS);
+    return c.replace(code, replacements);
 };
-export { transformReactiveObjects };

package/build/transformer/transforms/primitives.d.ts

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

package/build/transformer/transforms/primitives.js

@@ -1,14 +1,31 @@
-import { uid } from '@esportsplus/typescript/transformer';
-import { addMissingImports, applyReplacements } from './utilities.js';
 import { ts } from '@esportsplus/typescript';
+import { code as c } from '@esportsplus/typescript/transformer';
+import { COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_TYPE_SIGNAL, PACKAGE } from '../../constants.js';
+let 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 classifyReactiveArg(arg) {
     if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-        return 'computed';
+        return COMPILATION_TYPE_COMPUTED;
     }
     if (ts.isObjectLiteralExpression(arg) || ts.isArrayLiteralExpression(arg)) {
         return null;
     }
-    return 'signal';
+    return COMPILATION_TYPE_SIGNAL;
 }
 function findBinding(bindings, name, node) {
     for (let i = 0, n = bindings.length; i < n; i++) {
@@ -36,56 +53,6 @@ function findEnclosingScope(node) {
     }
     return node.getSourceFile();
 }
-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 isInComputedRange(ranges, start, end) {
     for (let i = 0, n = ranges.length; i < n; i++) {
         let r = ranges[i];
@@ -97,10 +64,7 @@ function isInComputedRange(ranges, start, end) {
 }
 function isInDeclarationInit(node) {
     let parent = node.parent;
-    if (ts.isVariableDeclaration(parent) && parent.initializer === node) {
-        return true;
-    }
-    return false;
+    return ts.isVariableDeclaration(parent) && parent.initializer === node;
 }
 function isInScope(reference, binding) {
     let current = reference;
@@ -119,7 +83,7 @@ function isReactiveReassignment(node) {
         parent.right === node &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive') {
+        node.expression.text === COMPILATION_ENTRYPOINT) {
         return true;
     }
     return false;
@@ -131,12 +95,7 @@ function isWriteContext(node) {
         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) {
+        if (COMPOUND_OPERATORS.has(op)) {
             return 'compound';
         }
     }
@@ -151,11 +110,11 @@ function isWriteContext(node) {
 function visit(ctx, node) {
     if (ts.isImportDeclaration(node) &&
         ts.isStringLiteral(node.moduleSpecifier) &&
-        node.moduleSpecifier.text.includes('@esportsplus/reactivity')) {
+        node.moduleSpecifier.text.includes(PACKAGE)) {
         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') {
+                if (clause.namedBindings.elements[i].name.text === COMPILATION_ENTRYPOINT) {
                     ctx.hasReactiveImport = true;
                     break;
                 }
@@ -165,15 +124,16 @@ function visit(ctx, node) {
     if (ctx.hasReactiveImport &&
         ts.isCallExpression(node) &&
         ts.isIdentifier(node.expression) &&
-        node.expression.text === 'reactive' &&
+        node.expression.text === COMPILATION_ENTRYPOINT &&
         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)) {
+            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 varName = node.parent.name.text;
             }
-            else if (ts.isBinaryExpression(node.parent) &&
+            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;
@@ -183,39 +143,34 @@ function visit(ctx, node) {
                 ctx.scopedBindings.push({ name: varName, scope, type: classification });
                 ctx.bindings.set(varName, classification);
             }
-            if (classification === 'computed') {
-                ctx.computedArgRanges.push({
-                    end: arg.end,
-                    start: arg.getStart(ctx.sourceFile)
-                });
+            if (classification === COMPILATION_TYPE_COMPUTED) {
+                let argStart = arg.getStart(ctx.sourceFile);
+                ctx.computedArgRanges.push({ end: arg.end, start: argStart });
                 let argCtx = {
-                    argStart: arg.getStart(ctx.sourceFile),
+                    argStart,
                     innerReplacements: [],
-                    neededImports: ctx.neededImports,
+                    ns: ctx.ns,
                     scopedBindings: ctx.scopedBindings,
                     sourceFile: ctx.sourceFile
                 };
                 visitArg(argCtx, arg);
-                let argText = applyReplacements(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
+                let argText = c.replace(arg.getText(ctx.sourceFile), argCtx.innerReplacements);
                 ctx.replacements.push({
                     end: node.end,
-                    newText: `computed(${argText})`,
+                    newText: `${ctx.ns}.computed(${argText})`,
                     start: node.pos
                 });
-                ctx.neededImports.add('computed');
             }
             else {
-                let argText = arg.getText(ctx.sourceFile);
                 ctx.replacements.push({
                     end: node.end,
-                    newText: `signal(${argText})`,
+                    newText: `${ctx.ns}.signal(${arg.getText(ctx.sourceFile)})`,
                     start: node.pos
                 });
-                ctx.neededImports.add('signal');
             }
         }
     }
-    if (ts.isIdentifier(node) && !isInDeclarationInit(node.parent)) {
+    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;
@@ -226,51 +181,49 @@ function visit(ctx, node) {
             return;
         }
         let binding = findBinding(ctx.scopedBindings, node.text, node), name = node.text;
-        if (binding) {
+        if (binding && node.parent) {
             if (!isReactiveReassignment(node.parent) &&
                 !(ts.isTypeOfExpression(node.parent) && node.parent.expression === node)) {
                 let writeCtx = isWriteContext(node);
                 if (writeCtx) {
-                    if (binding.type !== 'computed') {
-                        ctx.neededImports.add('set');
+                    if (binding.type !== COMPILATION_TYPE_COMPUTED) {
                         let parent = node.parent;
                         if (writeCtx === 'simple' && ts.isBinaryExpression(parent)) {
-                            let valueText = parent.right.getText(ctx.sourceFile);
                             ctx.replacements.push({
                                 end: parent.end,
-                                newText: `set(${name}, ${valueText})`,
+                                newText: `${ctx.ns}.write(${name}, ${parent.right.getText(ctx.sourceFile)})`,
                                 start: parent.pos
                             });
                         }
                         else if (writeCtx === 'compound' && ts.isBinaryExpression(parent)) {
-                            let op = getCompoundOperator(parent.operatorToken.kind), valueText = parent.right.getText(ctx.sourceFile);
+                            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind) ?? '+';
                             ctx.replacements.push({
                                 end: parent.end,
-                                newText: `set(${name}, ${name}.value ${op} ${valueText})`,
+                                newText: `${ctx.ns}.write(${name}, ${name}.value ${op} ${parent.right.getText(ctx.sourceFile)})`,
                                 start: parent.pos
                             });
                         }
                         else if (writeCtx === 'increment') {
-                            let isPrefix = ts.isPrefixUnaryExpression(parent), op = parent.operator, delta = op === ts.SyntaxKind.PlusPlusToken ? '+ 1' : '- 1';
+                            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: `set(${name}, ${name}.value ${delta})`,
+                                    newText: `${ctx.ns}.write(${name}, ${name}.value ${delta})`,
                                     start: parent.pos
                                 });
                             }
                             else if (isPrefix) {
                                 ctx.replacements.push({
                                     end: parent.end,
-                                    newText: `(set(${name}, ${name}.value ${delta}), ${name}.value)`,
+                                    newText: `(${ctx.ns}.write(${name}, ${name}.value ${delta}), ${name}.value)`,
                                     start: parent.pos
                                 });
                             }
                             else {
-                                let tmp = uid('tmp');
+                                let tmp = `_t${ctx.tmpCounter++}`;
                                 ctx.replacements.push({
                                     end: parent.end,
-                                    newText: `((${tmp}) => (set(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
+                                    newText: `((${tmp}) => (${ctx.ns}.write(${name}, ${tmp} ${delta}), ${tmp}))(${name}.value)`,
                                     start: parent.pos
                                 });
                             }
@@ -278,10 +231,9 @@ function visit(ctx, node) {
                     }
                 }
                 else {
-                    ctx.neededImports.add('read');
                     ctx.replacements.push({
                         end: node.end,
-                        newText: `read(${name})`,
+                        newText: `${ctx.ns}.read(${name})`,
                         start: node.pos
                     });
                 }
@@ -291,45 +243,36 @@ function visit(ctx, node) {
     ts.forEachChild(node, n => visit(ctx, n));
 }
 function visitArg(ctx, node) {
-    if (ts.isIdentifier(node)) {
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === 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 (ts.isCallExpression(node.parent) && node.parent.expression === node) {
-            ts.forEachChild(node, n => visitArg(ctx, n));
-            return;
-        }
-        let binding = findBinding(ctx.scopedBindings, node.text, node);
-        if (binding) {
-            ctx.neededImports.add('read');
+        if (findBinding(ctx.scopedBindings, node.text, node)) {
             ctx.innerReplacements.push({
                 end: node.end - ctx.argStart,
-                newText: `read(${node.text})`,
+                newText: `${ctx.ns}.read(${node.text})`,
                 start: node.getStart(ctx.sourceFile) - ctx.argStart
             });
         }
     }
     ts.forEachChild(node, n => visitArg(ctx, n));
 }
-const transformReactivePrimitives = (sourceFile, bindings) => {
+export default (sourceFile, bindings, ns) => {
     let code = sourceFile.getFullText(), ctx = {
         bindings,
         computedArgRanges: [],
         hasReactiveImport: false,
-        neededImports: new Set(),
+        ns,
         replacements: [],
         scopedBindings: [],
-        sourceFile
+        sourceFile,
+        tmpCounter: 0
     };
     visit(ctx, sourceFile);
     if (ctx.replacements.length === 0) {
         return code;
     }
-    let result = applyReplacements(code, ctx.replacements);
-    if (ctx.neededImports.size > 0) {
-        result = addMissingImports(result, ctx.neededImports);
-    }
-    return result;
+    return c.replace(code, ctx.replacements);
 };
-export { transformReactivePrimitives };

package/build/types.d.ts

@@ -1,5 +1,4 @@
 import { COMPUTED, SIGNAL, STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_RECOMPUTING } from './constants.js';
-import { ReactiveArray, ReactiveObject } from './reactive/index.js';
 import { ts } from '@esportsplus/typescript';
 type BindingType = 'array' | 'computed' | 'object' | 'signal';
 type Bindings = Map<string, BindingType>;
@@ -25,6 +24,7 @@ interface Link {
     sub: Computed<unknown>;
     version: number;
 }
+type Reactive<T> = T;
 type Signal<T> = {
     subs: Link | null;
     subsTail: Link | null;
@@ -36,4 +36,4 @@ interface TransformResult {
     sourceFile: ts.SourceFile;
     transformed: boolean;
 }
-export type { BindingType, Bindings, Computed, Link, ReactiveArray, ReactiveObject, Signal, TransformResult };
+export type { BindingType, Bindings, Computed, Link, Reactive, Signal, TransformResult };

package/package.json

@@ -4,7 +4,7 @@
     "@esportsplus/utilities": "^0.27.2"
   },
   "devDependencies": {
-    "@esportsplus/typescript": "^0.17.3",
+    "@esportsplus/typescript": "^0.17.5",
     "@types/node": "^25.0.3",
     "vite": "^7.3.0"
   },
@@ -18,13 +18,13 @@
       "types": "./build/constants.d.ts"
     },
     "./plugins/tsc": {
+      "types": "./build/transformer/plugins/tsc.d.ts",
       "import": "./build/transformer/plugins/tsc.js",
-      "require": "./build/transformer/plugins/tsc.js",
-      "types": "./build/transformer/plugins/tsc.d.ts"
+      "require": "./build/transformer/plugins/tsc.js"
     },
     "./plugins/vite": {
-      "import": "./build/transformer/plugins/vite.js",
-      "types": "./build/transformer/plugins/vite.d.ts"
+      "types": "./build/transformer/plugins/vite.d.ts",
+      "import": "./build/transformer/plugins/vite.js"
     }
   },
   "main": "build/index.js",
@@ -36,7 +36,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.25.2",
+  "version": "0.25.4",
   "scripts": {
     "build": "tsc",
     "build:test": "pnpm build && vite build --config test/vite.config.ts",

package/readme.md

@@ -107,7 +107,7 @@ The library requires a build-time transformer to convert `reactive()` calls into
 ```typescript
 // vite.config.ts
 import { defineConfig } from 'vite';
-import { plugin as reactivity } from '@esportsplus/reactivity/plugins/vite';
+import reactivity from '@esportsplus/reactivity/plugins/vite';
 
 export default defineConfig({
     plugins: [
@@ -146,12 +146,12 @@ console.log(doubled);
 
 **Output:**
 ```typescript
-import { computed, read, set, signal } from '@esportsplus/reactivity';
+import { computed, read, signal, write } from '@esportsplus/reactivity';
 
 let count = signal(0);
 let doubled = computed(() => read(count) * 2);
 
-set(count, 5);
+write(count, 5);
 console.log(read(doubled));
 ```
 
@@ -172,7 +172,7 @@ class ReactiveObject_1 {
     #greeting = null;
 
     get name() { return read(this.#name); }
-    set name(v) { set(this.#name, v); }
+    set name(v) { write(this.#name, v); }
     get greeting() { return read(this.#greeting ??= computed(() => `Hello, ${this.name}`)); }
 
     dispose() {
@@ -206,7 +206,7 @@ These are typically only used by the transformer output:
 | `signal(value)` | Creates a raw signal |
 | `computed(fn)` | Creates a raw computed |
 | `read(node)` | Reads a signal or computed value |
-| `set(signal, value)` | Sets a signal value |
+| `write(signal, value)` | Sets a signal value |
 | `dispose(computed)` | Disposes a computed and its dependencies |
 
 ### Type Guards

package/src/constants.ts

@@ -1,5 +1,20 @@
+const COMPILATION_ENTRYPOINT = 'reactive';
+
+const COMPILATION_ENTRYPOINT_REGEX = /\breactive\b/;
+
+const COMPILATION_NAMESPACE = 'reactive';
+
+const COMPILATION_TYPE_ARRAY = 'array';
+
+const COMPILATION_TYPE_COMPUTED = 'computed';
+
+const COMPILATION_TYPE_SIGNAL = 'signal';
+
+
 const COMPUTED = Symbol('reactivity.computed');
 
+const PACKAGE = '@esportsplus/reactivity';
+
 const REACTIVE_ARRAY = Symbol('reactivity.reactive.array');
 
 const REACTIVE_OBJECT = Symbol('reactivity.reactive.object');
@@ -30,18 +45,10 @@ const STATE_NOTIFY_MASK = (STATE_CHECK | STATE_DIRTY);
 
 
 export {
-    COMPUTED,
-    REACTIVE_ARRAY,
-    REACTIVE_OBJECT,
+    COMPILATION_TYPE_ARRAY, COMPILATION_TYPE_COMPUTED, COMPILATION_ENTRYPOINT, COMPILATION_ENTRYPOINT_REGEX, COMPILATION_NAMESPACE, COMPILATION_TYPE_SIGNAL, COMPUTED,
+    PACKAGE,
+    REACTIVE_ARRAY, REACTIVE_OBJECT,
     SIGNAL,
-    STABILIZER_IDLE,
-    STATE_NOTIFY_MASK,
-    STABILIZER_RESCHEDULE,
-    STABILIZER_RUNNING,
-    STABILIZER_SCHEDULED,
-    STATE_CHECK,
-    STATE_DIRTY,
-    STATE_IN_HEAP,
-    STATE_NONE,
-    STATE_RECOMPUTING
+    STABILIZER_IDLE, STABILIZER_RESCHEDULE, STABILIZER_RUNNING, STABILIZER_SCHEDULED,
+    STATE_CHECK, STATE_DIRTY, STATE_IN_HEAP, STATE_NONE, STATE_NOTIFY_MASK, STATE_RECOMPUTING
 };