@fluixi/compiler 1.0.0-alpha.100

package/dist/transform/bindings.cjs

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transform/bindings.ts
+var bindings_exports = {};
+__export(bindings_exports, {
+  moduleBindings: () => moduleBindings
+});
+module.exports = __toCommonJS(bindings_exports);
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}

package/dist/transform/bindings.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Names bound at module scope.
+ *
+ * Injected imports are skipped when the name already exists, so a file with its
+ * own `Show` keeps it. Only module scope matters: a `const insert = …` inside a
+ * function shadows our import there but cannot collide with it, which is the same
+ * answer `path.scope.hasBinding` gives on the Program path.
+ *
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
+ * that isn't there drops an import the code needs. Both are loud, neither is
+ * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
+ */
+/** Collect the names bound at the top level of a parsed module. */
+export declare function moduleBindings(program: {
+    body: unknown[];
+}): Set<string>;

package/dist/transform/bindings.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Names bound at module scope.
+ *
+ * Injected imports are skipped when the name already exists, so a file with its
+ * own `Show` keeps it. Only module scope matters: a `const insert = …` inside a
+ * function shadows our import there but cannot collide with it, which is the same
+ * answer `path.scope.hasBinding` gives on the Program path.
+ *
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
+ * that isn't there drops an import the code needs. Both are loud, neither is
+ * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
+ */
+/** Collect the names bound at the top level of a parsed module. */
+export declare function moduleBindings(program: {
+    body: unknown[];
+}): Set<string>;
+//# sourceMappingURL=bindings.d.ts.map

package/dist/transform/bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../src/transform/bindings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAoDH,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CAIxE"}

package/dist/transform/bindings.js

@@ -0,0 +1,69 @@
+/**
+ * Names bound at module scope.
+ *
+ * Injected imports are skipped when the name already exists, so a file with its
+ * own `Show` keeps it. Only module scope matters: a `const insert = …` inside a
+ * function shadows our import there but cannot collide with it, which is the same
+ * answer `path.scope.hasBinding` gives on the Program path.
+ *
+ * Missing a binding emits a duplicate declaration, a syntax error. Reporting one
+ * that isn't there drops an import the code needs. Both are loud, neither is
+ * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
+ */
+/** Every name a destructuring pattern (or plain identifier) introduces. */
+function patternNames(node, out) {
+    if (!node)
+        return;
+    switch (node.type) {
+        case 'Identifier':
+            out.add(node.name);
+            return;
+        case 'ObjectPattern':
+            for (const p of node.properties) {
+                if (p.type === 'RestElement')
+                    patternNames(p.argument, out);
+                else
+                    patternNames(p.value, out);
+            }
+            return;
+        case 'ArrayPattern':
+            for (const e of node.elements)
+                patternNames(e, out);
+            return;
+        case 'AssignmentPattern':
+            patternNames(node.left, out);
+            return;
+        case 'RestElement':
+            patternNames(node.argument, out);
+            return;
+    }
+}
+function declared(node, out) {
+    switch (node.type) {
+        case 'ImportDeclaration':
+            for (const s of node.specifiers)
+                patternNames(s.local, out);
+            return;
+        case 'VariableDeclaration':
+            for (const d of node.declarations)
+                patternNames(d.id, out);
+            return;
+        case 'FunctionDeclaration':
+        case 'ClassDeclaration':
+            patternNames(node.id, out);
+            return;
+        case 'ExportNamedDeclaration':
+        case 'ExportDefaultDeclaration':
+            // `export const x = 1` / `export function f() {}` bind too.
+            if (node.declaration)
+                declared(node.declaration, out);
+            return;
+    }
+}
+/** Collect the names bound at the top level of a parsed module. */
+export function moduleBindings(program) {
+    const names = new Set();
+    for (const statement of program.body)
+        declared(statement, names);
+    return names;
+}

package/dist/transform/bindings.mjs

@@ -0,0 +1,50 @@
+// src/transform/bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}
+export {
+  moduleBindings
+};