@signaltree/callable-syntax 6.0.0 → 6.0.1

package/dist/augmentation.js

@@ -0,0 +1 @@
+

package/dist/index.js

@@ -0,0 +1,3 @@
+export { DEFAULT_ROOT_IDENTIFIERS, transformCode } from './lib/ast-transform.js';
+export { signalTreeSyntaxTransform } from './lib/vite-plugin.js';
+export { SignalTreeSyntaxWebpackPlugin } from './lib/webpack-plugin.js';

package/dist/lib/ast-transform.js

@@ -0,0 +1,74 @@
+import generate from '@babel/generator';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+const DEFAULT_ROOT_IDENTIFIERS = ['tree'];
+function transformCode(source, options = {}) {
+  var _a;
+  const rootIds = ((_a = options.rootIdentifiers) === null || _a === void 0 ? void 0 : _a.length) ? options.rootIdentifiers : DEFAULT_ROOT_IDENTIFIERS;
+  const ast = parseSourceCode(source);
+  let transformCount = 0;
+  traverse(ast, {
+    CallExpression(path) {
+      const {
+        node
+      } = path;
+      if (!t.isCallExpression(node)) return;
+      if (shouldTransformCallExpression(node, rootIds)) {
+        const transformedCall = createTransformedCall(node);
+        path.replaceWith(transformedCall);
+        transformCount++;
+      }
+    }
+  });
+  const output = generate(ast, {
+    retainLines: false,
+    comments: true
+  }, source);
+  if (options.debug && transformCount > 0) {
+    console.log(`[signaltree callable-syntax] transformed ${transformCount} calls`);
+  }
+  return {
+    code: output.code,
+    transformed: transformCount
+  };
+}
+function parseSourceCode(source) {
+  return parse(source, {
+    sourceType: 'module',
+    plugins: ['typescript', 'jsx']
+  });
+}
+function shouldTransformCallExpression(node, rootIds) {
+  if (!t.isMemberExpression(node.callee)) return false;
+  if (node.arguments.length === 0) return false;
+  if (isAlreadyTransformed(node.callee)) return false;
+  return isRootedSignalAccess(node.callee, rootIds);
+}
+function isAlreadyTransformed(callee) {
+  return t.isIdentifier(callee.property) && (callee.property.name === 'set' || callee.property.name === 'update');
+}
+function createTransformedCall(node) {
+  const callee = node.callee;
+  const method = determineMethod(node.arguments[0]);
+  return t.callExpression(t.memberExpression(callee, t.identifier(method)), node.arguments);
+}
+function determineMethod(firstArg) {
+  if (t.isFunctionExpression(firstArg) || t.isArrowFunctionExpression(firstArg)) {
+    return 'update';
+  }
+  return 'set';
+}
+function isRootedSignalAccess(expr, roots) {
+  let current = expr;
+  while (t.isMemberExpression(current)) {
+    if (t.isIdentifier(current.object)) {
+      return roots.includes(current.object.name);
+    }
+    current = current.object;
+  }
+  return false;
+}
+
+export { DEFAULT_ROOT_IDENTIFIERS, transformCode };

package/dist/lib/vite-plugin.js

@@ -0,0 +1,25 @@
+import { transformCode } from './ast-transform.js';
+
+function signalTreeSyntaxTransform(options = {}) {
+  var _a, _b;
+  const include = (_a = options.include) !== null && _a !== void 0 ? _a : /src\/.*\.(t|j)sx?$/;
+  const exclude = (_b = options.exclude) !== null && _b !== void 0 ? _b : /node_modules|\.spec\.|\.test\./;
+  return {
+    name: 'signaltree-callable-syntax',
+    enforce: 'pre',
+    transform(code, id) {
+      if (!include.test(id) || exclude.test(id)) return null;
+      const result = transformCode(code, {
+        rootIdentifiers: options.rootIdentifiers,
+        debug: options.debug
+      });
+      if (result.transformed === 0) return null;
+      return {
+        code: result.code,
+        map: null
+      };
+    }
+  };
+}
+
+export { signalTreeSyntaxTransform };

package/dist/lib/webpack-plugin.js

@@ -0,0 +1,44 @@
+import { transformCode } from './ast-transform.js';
+
+class SignalTreeSyntaxWebpackPlugin {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  apply(compiler) {
+    var _a, _b;
+    const test = (_a = this.options.test) !== null && _a !== void 0 ? _a : /src\/.*\.(t|j)sx?$/;
+    const exclude = (_b = this.options.exclude) !== null && _b !== void 0 ? _b : /node_modules|\.spec\.|\.test\./;
+    compiler.hooks.emit.tapAsync('SignalTreeSyntaxWebpackPlugin', (compilation, cb) => {
+      for (const filename of Object.keys(compilation.assets)) {
+        if (!test.test(filename) || exclude.test(filename)) continue;
+        const asset = compilation.assets[filename];
+        const raw = asset.source();
+        let source;
+        if (typeof raw === 'string') {
+          source = raw;
+        } else if (Buffer.isBuffer(raw)) {
+          source = raw.toString('utf8');
+        } else {
+          source = String(raw);
+        }
+        const {
+          code,
+          transformed
+        } = transformCode(source, {
+          rootIdentifiers: this.options.rootIdentifiers,
+          debug: this.options.debug
+        });
+        if (transformed > 0) {
+          const updated = code;
+          compilation.assets[filename] = {
+            source: () => updated,
+            size: () => Buffer.byteLength(updated, 'utf8')
+          };
+        }
+      }
+      cb();
+    });
+  }
+}
+
+export { SignalTreeSyntaxWebpackPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaltree/callable-syntax",
-  "version": "6.0.0",
+  "version": "6.0.1",
   "description": "Optional zero-runtime callable syntax transform for SignalTree unified leaf API.",
   "license": "BSL-1.1",
   "type": "module",

package/src/augmentation.d.ts

@@ -1,10 +1 @@
-import '@angular/core';
-
-// Augment Angular WritableSignal so leaves support callable set/update like NodeAccessor.
-// Getter signature already exists on WritableSignal.
-declare module '@angular/core' {
-  interface WritableSignal<T> {
-    (value: T extends (...args: unknown[]) => unknown ? never : T): void;
-    (updater: (current: T) => T): void;
-  }
-}
+export {};

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/ast-transform';
+export * from './lib/vite-plugin';
+export * from './lib/webpack-plugin';
+export * from './augmentation';

package/src/lib/ast-transform.d.ts

@@ -0,0 +1,10 @@
+export interface TransformOptions {
+    readonly rootIdentifiers?: string[];
+    readonly debug?: boolean;
+}
+export interface TransformResult {
+    code: string;
+    transformed: number;
+}
+export declare const DEFAULT_ROOT_IDENTIFIERS: string[];
+export declare function transformCode(source: string, options?: TransformOptions): TransformResult;

package/src/lib/syntax-transform.d.ts

@@ -0,0 +1 @@
+export declare const syntaxTransform: () => string;

package/src/lib/vite-plugin.d.ts

@@ -0,0 +1,16 @@
+type Plugin = {
+    name: string;
+    enforce?: 'pre' | 'post';
+    transform?: (code: string, id: string) => {
+        code: string;
+        map: null;
+    } | null;
+};
+export interface SignalTreeVitePluginOptions {
+    include?: RegExp;
+    exclude?: RegExp;
+    rootIdentifiers?: string[];
+    debug?: boolean;
+}
+export declare function signalTreeSyntaxTransform(options?: SignalTreeVitePluginOptions): Plugin;
+export {};

package/src/lib/webpack-plugin.d.ts

@@ -0,0 +1,25 @@
+interface CompilationLike {
+    assets: Record<string, {
+        source(): unknown;
+        size(): number;
+    }>;
+}
+interface CompilerLike {
+    hooks: {
+        emit: {
+            tapAsync(name: string, cb: (compilation: CompilationLike, done: (err?: Error) => void) => void): void;
+        };
+    };
+}
+export interface SignalTreeWebpackPluginOptions {
+    test?: RegExp;
+    exclude?: RegExp;
+    rootIdentifiers?: string[];
+    debug?: boolean;
+}
+export declare class SignalTreeSyntaxWebpackPlugin {
+    private readonly options;
+    constructor(options?: SignalTreeWebpackPluginOptions);
+    apply(compiler: CompilerLike): void;
+}
+export {};