@collie-lang/cli 1.3.3 → 1.4.0

package/dist/index.js

@@ -28,7 +28,7 @@ var import_node_child_process2 = require("child_process");
 var import_promises8 = __toESM(require("fs/promises"));
 var import_node_fs3 = require("fs");
 var import_node_path8 = __toESM(require("path"));
-var import_typescript = __toESM(require("typescript"));
+var import_typescript2 = __toESM(require("typescript"));
 var import_fast_glob4 = __toESM(require("fast-glob"));
 var import_diff = require("diff");
 var import_picocolors7 = __toESM(require("picocolors"));
@@ -784,11 +784,13 @@ function printSuccessMessage(config) {
 // src/converter.ts
 var import_promises6 = __toESM(require("fs/promises"));
 var import_node_path6 = __toESM(require("path"));
+var import_typescript = __toESM(require("typescript"));
 var import_compiler5 = require("@collie-lang/compiler");
 async function convertFile(filepath, options = {}) {
   const source = await import_promises6.default.readFile(filepath, "utf8");
   const result = (0, import_compiler5.convertTsxToCollie)(source, { filename: filepath });
-  const { collie, warnings } = result;
+  const collie = normalizeConvertedCollie(result.collie, source, filepath);
+  const { warnings } = result;
   let outputPath;
   if (options.write) {
     outputPath = resolveOutputPath2(filepath);
@@ -806,6 +808,195 @@ async function convertFile(filepath, options = {}) {
   }
   return { collie, warnings, outputPath };
 }
+function normalizeConvertedCollie(collie, source, filename) {
+  const { localParamNames, componentParamNames } = collectLocalFunctionParams(source, filename);
+  const lines = collie.replace(/\r\n?/g, "\n").split("\n");
+  const normalized = [];
+  let inInputs = false;
+  let inputsIndent = 0;
+  let inputsHeader = "";
+  let inputLines = [];
+  let seenInputs = /* @__PURE__ */ new Set();
+  const flushInputsBlock = () => {
+    if (!inInputs) {
+      return;
+    }
+    if (inputLines.length > 0) {
+      normalized.push(inputsHeader, ...inputLines);
+    }
+    inInputs = false;
+    inputsHeader = "";
+    inputLines = [];
+    seenInputs = /* @__PURE__ */ new Set();
+  };
+  let i = 0;
+  while (i < lines.length) {
+    const rawLine = lines[i];
+    const indentMatch = rawLine.match(/^\s*/);
+    const indent = indentMatch ? indentMatch[0].length : 0;
+    const trimmed = rawLine.trimEnd();
+    if (!inInputs) {
+      if (trimmed === "#inputs") {
+        inInputs = true;
+        inputsIndent = indent;
+        inputsHeader = rawLine;
+        inputLines = [];
+        seenInputs = /* @__PURE__ */ new Set();
+        i++;
+        continue;
+      }
+      normalized.push(rawLine);
+      i++;
+      continue;
+    }
+    if (trimmed !== "" && indent <= inputsIndent) {
+      flushInputsBlock();
+      continue;
+    }
+    if (trimmed === "") {
+      i++;
+      continue;
+    }
+    const content = trimmed.trim();
+    const nameMatch = content.match(/^([A-Za-z_$][A-Za-z0-9_$]*)/);
+    if (!nameMatch) {
+      i++;
+      continue;
+    }
+    const name = nameMatch[1];
+    if (localParamNames.has(name) && !componentParamNames.has(name)) {
+      i++;
+      continue;
+    }
+    if (!seenInputs.has(name)) {
+      const lineIndent = rawLine.slice(0, indent);
+      inputLines.push(`${lineIndent}${name}`);
+      seenInputs.add(name);
+    }
+    i++;
+  }
+  flushInputsBlock();
+  return normalized.join("\n");
+}
+function collectLocalFunctionParams(source, filename) {
+  const sourceFile = import_typescript.default.createSourceFile(
+    filename,
+    source,
+    import_typescript.default.ScriptTarget.Latest,
+    true,
+    inferScriptKind(filename)
+  );
+  const componentNode = findComponentFunction(sourceFile);
+  const componentParamNames = /* @__PURE__ */ new Set();
+  if (componentNode) {
+    collectParamNames(componentNode.parameters, componentParamNames, sourceFile);
+  }
+  const localParamNames = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (isFunctionNode(node) && node !== componentNode) {
+      collectParamNames(node.parameters, localParamNames, sourceFile);
+    }
+    import_typescript.default.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return { localParamNames, componentParamNames };
+}
+function isFunctionNode(node) {
+  return import_typescript.default.isFunctionDeclaration(node) || import_typescript.default.isFunctionExpression(node) || import_typescript.default.isArrowFunction(node) || import_typescript.default.isMethodDeclaration(node);
+}
+function collectParamNames(params, names, sourceFile) {
+  for (const param of params) {
+    collectBindingNames(param.name, names, sourceFile);
+  }
+}
+function collectBindingNames(name, names, sourceFile) {
+  if (import_typescript.default.isIdentifier(name)) {
+    names.add(name.text);
+    return;
+  }
+  if (import_typescript.default.isObjectBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (element.propertyName) {
+        const propName = getPropertyNameText(element.propertyName, sourceFile);
+        if (propName) {
+          names.add(propName);
+        }
+      }
+      collectBindingNames(element.name, names, sourceFile);
+    }
+    return;
+  }
+  if (import_typescript.default.isArrayBindingPattern(name)) {
+    for (const element of name.elements) {
+      if (import_typescript.default.isBindingElement(element)) {
+        collectBindingNames(element.name, names, sourceFile);
+      }
+    }
+  }
+}
+function getPropertyNameText(name, sourceFile) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
+  }
+  const raw = name.getText(sourceFile);
+  return raw ? raw : null;
+}
+function findComponentFunction(sourceFile) {
+  for (const statement of sourceFile.statements) {
+    if (import_typescript.default.isFunctionDeclaration(statement) && statement.body) {
+      if (findJsxReturn(statement.body)) {
+        return statement;
+      }
+    }
+    if (import_typescript.default.isVariableStatement(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        const init = decl.initializer;
+        if (!init) continue;
+        if (import_typescript.default.isArrowFunction(init) || import_typescript.default.isFunctionExpression(init)) {
+          if (findJsxInFunctionBody(init.body)) {
+            return init;
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+function findJsxReturn(body) {
+  for (const statement of body.statements) {
+    if (import_typescript.default.isReturnStatement(statement) && statement.expression) {
+      const jsx = unwrapJsx(statement.expression);
+      if (jsx) {
+        return jsx;
+      }
+    }
+  }
+  return void 0;
+}
+function findJsxInFunctionBody(body) {
+  if (import_typescript.default.isBlock(body)) {
+    return findJsxReturn(body);
+  }
+  return unwrapJsx(body);
+}
+function unwrapJsx(expression) {
+  let current = expression;
+  while (import_typescript.default.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  if (import_typescript.default.isJsxElement(current) || import_typescript.default.isJsxFragment(current) || import_typescript.default.isJsxSelfClosingElement(current)) {
+    return current;
+  }
+  return void 0;
+}
+function inferScriptKind(filename) {
+  const dotIndex = filename.lastIndexOf(".");
+  const ext = dotIndex === -1 ? "" : filename.slice(dotIndex).toLowerCase();
+  if (ext === ".tsx") return import_typescript.default.ScriptKind.TSX;
+  if (ext === ".jsx") return import_typescript.default.ScriptKind.JSX;
+  if (ext === ".ts") return import_typescript.default.ScriptKind.TS;
+  return import_typescript.default.ScriptKind.JS;
+}
 function resolveOutputPath2(filepath) {
   return filepath.replace(/\.[tj]sx?$/, "") + ".collie";
 }
@@ -1082,7 +1273,7 @@ async function checkCollieFiles(context) {
   };
 }
 async function testCompilation() {
-  const template = ["props", '  name: string = "world"', "", 'div class="doctor-check"', "  h1", "    Hello {{ name }}"].join(
+  const template = ["#inputs", "  name", "", 'div class="doctor-check"', "  h1", "    Hello {{ name }}"].join(
     "\n"
   );
   try {
@@ -2076,30 +2267,30 @@ async function patchViteConfig(configPath) {
   }
 }
 function transformViteConfig(source) {
-  const sourceFile = import_typescript.default.createSourceFile(
+  const sourceFile = import_typescript2.default.createSourceFile(
     "vite.config.ts",
     source,
-    import_typescript.default.ScriptTarget.Latest,
+    import_typescript2.default.ScriptTarget.Latest,
     true,
-    import_typescript.default.ScriptKind.TS
+    import_typescript2.default.ScriptKind.TS
   );
   let needsImport = !source.includes("@collie-lang/vite");
   let needsPlugin = !/\bcollie\s*\(/.test(source);
   let changed = false;
-  const printer = import_typescript.default.createPrinter({ newLine: import_typescript.default.NewLineKind.LineFeed });
+  const printer = import_typescript2.default.createPrinter({ newLine: import_typescript2.default.NewLineKind.LineFeed });
   const transformer = (context) => {
     return (rootNode) => {
       function visit(node) {
-        if (needsImport && import_typescript.default.isImportDeclaration(node)) {
+        if (needsImport && import_typescript2.default.isImportDeclaration(node)) {
           return node;
         }
-        if (import_typescript.default.isCallExpression(node) && import_typescript.default.isIdentifier(node.expression) && node.expression.text === "defineConfig" && node.arguments.length > 0) {
+        if (import_typescript2.default.isCallExpression(node) && import_typescript2.default.isIdentifier(node.expression) && node.expression.text === "defineConfig" && node.arguments.length > 0) {
           const configArg = node.arguments[0];
-          if (import_typescript.default.isObjectLiteralExpression(configArg)) {
+          if (import_typescript2.default.isObjectLiteralExpression(configArg)) {
             const updatedConfig = updateConfigObject(configArg);
             if (updatedConfig !== configArg) {
               changed = true;
-              return import_typescript.default.factory.updateCallExpression(
+              return import_typescript2.default.factory.updateCallExpression(
                 node,
                 node.expression,
                 node.typeArguments,
@@ -2108,42 +2299,42 @@ function transformViteConfig(source) {
             }
           }
         }
-        return import_typescript.default.visitEachChild(node, visit, context);
+        return import_typescript2.default.visitEachChild(node, visit, context);
       }
       function updateConfigObject(configObj) {
         let pluginsProperty;
         const otherProperties = [];
         for (const prop of configObj.properties) {
-          if (import_typescript.default.isPropertyAssignment(prop) && import_typescript.default.isIdentifier(prop.name) && prop.name.text === "plugins") {
+          if (import_typescript2.default.isPropertyAssignment(prop) && import_typescript2.default.isIdentifier(prop.name) && prop.name.text === "plugins") {
             pluginsProperty = prop;
           } else {
             otherProperties.push(prop);
           }
         }
         let updatedPluginsArray;
-        if (pluginsProperty && import_typescript.default.isArrayLiteralExpression(pluginsProperty.initializer)) {
+        if (pluginsProperty && import_typescript2.default.isArrayLiteralExpression(pluginsProperty.initializer)) {
           updatedPluginsArray = ensurePluginOrdering(pluginsProperty.initializer);
           if (updatedPluginsArray === pluginsProperty.initializer) {
             return configObj;
           }
         } else if (needsPlugin) {
-          updatedPluginsArray = import_typescript.default.factory.createArrayLiteralExpression(
+          updatedPluginsArray = import_typescript2.default.factory.createArrayLiteralExpression(
             [createCollieCall()],
             false
           );
         } else {
           return configObj;
         }
-        const updatedPluginsProperty = import_typescript.default.factory.createPropertyAssignment(
+        const updatedPluginsProperty = import_typescript2.default.factory.createPropertyAssignment(
           "plugins",
           updatedPluginsArray
         );
         if (pluginsProperty) {
           const allProperties = [...otherProperties, updatedPluginsProperty];
-          return import_typescript.default.factory.updateObjectLiteralExpression(configObj, allProperties);
+          return import_typescript2.default.factory.updateObjectLiteralExpression(configObj, allProperties);
         } else {
           const allProperties = [...otherProperties, updatedPluginsProperty];
-          return import_typescript.default.factory.updateObjectLiteralExpression(configObj, allProperties);
+          return import_typescript2.default.factory.updateObjectLiteralExpression(configObj, allProperties);
         }
       }
       function ensurePluginOrdering(array) {
@@ -2153,7 +2344,7 @@ function transformViteConfig(source) {
         let reactIndex = -1;
         let collieIndex = -1;
         elements.forEach((elem, idx) => {
-          if (import_typescript.default.isCallExpression(elem) && import_typescript.default.isIdentifier(elem.expression)) {
+          if (import_typescript2.default.isCallExpression(elem) && import_typescript2.default.isIdentifier(elem.expression)) {
             if (elem.expression.text === "react") {
               hasReact = true;
               reactIndex = idx;
@@ -2169,7 +2360,7 @@ function transformViteConfig(source) {
             const newElements = [...elements];
             const colliePlugin = newElements.splice(collieIndex, 1)[0];
             newElements.splice(reactIndex, 0, colliePlugin);
-            return import_typescript.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
+            return import_typescript2.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
           }
           return array;
         }
@@ -2180,31 +2371,31 @@ function transformViteConfig(source) {
           } else {
             newElements.unshift(createCollieCall());
           }
-          return import_typescript.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
+          return import_typescript2.default.factory.createArrayLiteralExpression(newElements, isMultiLine);
         }
         return array;
       }
       function createCollieCall() {
-        return import_typescript.default.factory.createCallExpression(
-          import_typescript.default.factory.createIdentifier("collie"),
+        return import_typescript2.default.factory.createCallExpression(
+          import_typescript2.default.factory.createIdentifier("collie"),
           void 0,
           []
         );
       }
-      const visited = import_typescript.default.visitNode(rootNode, visit);
+      const visited = import_typescript2.default.visitNode(rootNode, visit);
       if (needsImport && changed) {
-        const collieImport = import_typescript.default.factory.createImportDeclaration(
+        const collieImport = import_typescript2.default.factory.createImportDeclaration(
           void 0,
-          import_typescript.default.factory.createImportClause(
+          import_typescript2.default.factory.createImportClause(
             false,
-            import_typescript.default.factory.createIdentifier("collie"),
+            import_typescript2.default.factory.createIdentifier("collie"),
             void 0
           ),
-          import_typescript.default.factory.createStringLiteral("@collie-lang/vite", true)
+          import_typescript2.default.factory.createStringLiteral("@collie-lang/vite", true)
         );
         let lastImportIndex = -1;
         for (let i = 0; i < visited.statements.length; i++) {
-          if (import_typescript.default.isImportDeclaration(visited.statements[i])) {
+          if (import_typescript2.default.isImportDeclaration(visited.statements[i])) {
             lastImportIndex = i;
           }
         }
@@ -2214,12 +2405,12 @@ function transformViteConfig(source) {
         } else {
           statements.unshift(collieImport);
         }
-        return import_typescript.default.factory.updateSourceFile(visited, statements);
+        return import_typescript2.default.factory.updateSourceFile(visited, statements);
       }
       return visited;
     };
   };
-  const result = import_typescript.default.transform(sourceFile, [transformer]);
+  const result = import_typescript2.default.transform(sourceFile, [transformer]);
   const transformedSourceFile = result.transformed[0];
   result.dispose();
   if (!changed) {
@@ -2233,7 +2424,7 @@ async function ensureCollieDeclaration(root) {
   if ((0, import_node_fs3.existsSync)(target)) return;
   await import_promises8.default.mkdir(import_node_path8.default.dirname(target), { recursive: true });
   const declaration = `// Allows importing Collie templates as React components.
-// Customize this typing if your templates expose specific props.
+// Customize this typing if your templates expose specific inputs.
 declare module "*.collie" {
   import type { ComponentType } from "react";
   const component: ComponentType<Record<string, unknown>>;