@pulse-compute/wasm-compiler 0.0.0 → 1.0.0-beta.2

package/src/patterns/handler-reference.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { match, unknown } = require('./result.js');
+
+function isInlineFunction(ts, node) {
+  return Boolean(node) && (ts.isArrowFunction(node) || ts.isFunctionExpression(node));
+}
+
+function classifyHandlerReference(ts, node) {
+  if (ts.isIdentifier(node)) return match({ kind: 'identifier', name: node.text });
+  if (isInlineFunction(ts, node)) {
+    return match({
+      kind: 'inline',
+      inlineKind: ts.isArrowFunction(node) ? 'inline-arrow' : 'inline-function-expression'
+    });
+  }
+  return unknown();
+}
+
+function classifyChannelReference(ts, node, isStringLiteralLike) {
+  if (isStringLiteralLike(ts, node)) return match({ kind: 'static', value: node.text });
+  return classifyHandlerReference(ts, node);
+}
+
+module.exports = {
+  classifyChannelReference,
+  classifyHandlerReference,
+  isInlineFunction
+};

package/src/patterns/path-literal.js

@@ -0,0 +1,35 @@
+'use strict';
+
+function isStringLiteralLike(ts, node) {
+  return Boolean(node) && (ts.isStringLiteral(node) || node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral);
+}
+
+function literalText(node) {
+  return node.text;
+}
+
+function nodeText(sourceFile, node) {
+  return node.getText(sourceFile).trim();
+}
+
+function unwrapExpression(ts, node) {
+  let current = node;
+  while (
+    current &&
+    (ts.isParenthesizedExpression(current) ||
+      ts.isAsExpression(current) ||
+      ts.isSatisfiesExpression?.(current) ||
+      ts.isNonNullExpression(current) ||
+      ts.isTypeAssertionExpression(current))
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+module.exports = {
+  isStringLiteralLike,
+  literalText,
+  nodeText,
+  unwrapExpression
+};

package/src/patterns/result.js

@@ -0,0 +1,15 @@
+'use strict';
+
+function match(value) {
+  return { status: 'match', value };
+}
+
+function reject(diagnostic) {
+  return { status: 'reject', diagnostic };
+}
+
+function unknown() {
+  return { status: 'unknown' };
+}
+
+module.exports = { match, reject, unknown };

package/src/patterns/router-chain-call.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const { DIAGNOSTIC_CODES } = require('../diagnostics/codes.js');
+
+function unwindRouterCallChain(ts, sourceFile, expr, diagnostics, diagnostic) {
+  const steps = [];
+  let cursor = expr;
+
+  while (ts.isCallExpression(cursor)) {
+    const callee = cursor.expression;
+    if (ts.isPropertyAccessExpression(callee)) {
+      steps.unshift({ method: callee.name.text, args: Array.from(cursor.arguments), node: cursor, nameNode: callee.name });
+      cursor = callee.expression;
+      continue;
+    }
+    if (ts.isElementAccessExpression(callee)) {
+      if (diagnostics && diagnostic) {
+        diagnostics.push(
+          diagnostic(
+            sourceFile,
+            callee,
+            DIAGNOSTIC_CODES.COMPUTED_METHOD,
+            'Computed router method calls are not supported in PulseWasm v1.',
+            'Use direct property calls such as app.get("/path", handler).',
+            { phase: 'extract' }
+          )
+        );
+      }
+      return null;
+    }
+    return null;
+  }
+
+  if (!ts.isIdentifier(cursor)) return null;
+  return { root: cursor.text, rootNode: cursor, steps };
+}
+
+function isOutermostCallInChain(ts, node) {
+  return !(
+    node.parent &&
+    ts.isPropertyAccessExpression(node.parent) &&
+    node.parent.parent &&
+    ts.isCallExpression(node.parent.parent)
+  );
+}
+
+module.exports = {
+  isOutermostCallInChain,
+  unwindRouterCallChain
+};

package/src/patterns/router-construction.js

@@ -0,0 +1,19 @@
+'use strict';
+
+function isRouterNewExpression(ts, init, unwrapExpression) {
+  const expr = unwrapExpression(ts, init);
+  return Boolean(expr && ts.isNewExpression(expr) && ts.isIdentifier(expr.expression) && ['Router', 'Pulse'].includes(expr.expression.text));
+}
+
+function isDirectRouterDeclarationInitializer(ts, node) {
+  let current = node;
+  while (current.parent && (ts.isParenthesizedExpression(current.parent) || ts.isAsExpression(current.parent) || ts.isNonNullExpression(current.parent))) {
+    current = current.parent;
+  }
+  return Boolean(current.parent && ts.isVariableDeclaration(current.parent) && current.parent.initializer === current && ts.isIdentifier(current.parent.name));
+}
+
+module.exports = {
+  isDirectRouterDeclarationInitializer,
+  isRouterNewExpression
+};