@kurotako/core 0.1.0 → 0.1.1

package/dist/index.js

@@ -77,24 +77,24 @@ var DependencyCycleError = class extends TakoError {
 var OutputCollisionError = class extends TakoError {
   path;
   generators;
-  constructor(path5, generators, hint) {
+  constructor(path6, generators, hint) {
     super(
       "output_collision",
-      `generators '${generators[0]}' and '${generators[1]}' both emit '${path5}'${hint ? `. ${hint}` : ""}`
+      `generators '${generators[0]}' and '${generators[1]}' both emit '${path6}'${hint ? `. ${hint}` : ""}`
     );
-    this.path = path5;
+    this.path = path6;
     this.generators = generators;
   }
 };
 var InvalidOutputPathError = class extends TakoError {
   path;
   generator;
-  constructor(path5, generator) {
+  constructor(path6, generator) {
     super(
       "invalid_output_path",
-      `generator '${generator}' emits '${path5}', which escapes the output root`
+      `generator '${generator}' emits '${path6}', which escapes the output root`
     );
-    this.path = path5;
+    this.path = path6;
     this.generator = generator;
   }
 };
@@ -186,12 +186,12 @@ ${guidance}`
 };
 var OutputNotGeneratedError = class extends TakoError {
   path;
-  constructor(path5) {
+  constructor(path6) {
     super(
       "output_not_generated",
-      `refusing to wipe '${path5}': it is non-empty and its package.json lacks the '"//": "Generated by tako\u2026"' marker`
+      `refusing to wipe '${path6}': it is non-empty and its package.json lacks the '"//": "Generated by tako\u2026"' marker`
     );
-    this.path = path5;
+    this.path = path6;
   }
 };
 var PackageInstallError = class extends TakoError {
@@ -258,6 +258,9 @@ function childLogger(base, prefixMeta) {
   };
 }
 
+// src/run.ts
+import { refCycleMembers } from "@kurotako/ir";
+
 // src/collect.ts
 import path from "path";
 function normalizePath(rawPath, generator) {
@@ -404,13 +407,8 @@ function findCycle(nodes, dependents) {
 }
 
 // src/merge.ts
-import {
-  assertIR,
-  IR_VERSION,
-  IrValidationError as IrModelValidationError,
-  validateSourceIR
-} from "@kurotako/ir";
-function mergeSources(entries) {
+import { IR_VERSION, validateIR, validateSourceIR } from "@kurotako/ir";
+function mergeSources(entries, logger) {
   const sources = {};
   for (const { namespace, sourceIR } of entries) {
     if (sourceIR.namespace !== namespace) {
@@ -426,26 +424,27 @@ function mergeSources(entries) {
     sources[namespace] = validation.value;
   }
   const ir = { irVersion: IR_VERSION, sources };
-  try {
-    assertIR(ir);
-  } catch (error) {
-    if (error instanceof IrModelValidationError) {
-      throw new IrValidationError(error.issues);
-    }
-    throw error;
+  const result = validateIR(ir);
+  if (!result.ok) {
+    throw new IrValidationError(result.issues);
+  }
+  for (const note of result.info ?? []) {
+    logger?.warn(
+      `IR ${note.code} at ${note.path === "" ? "<root>" : note.path}: ${note.message}`
+    );
   }
-  return ir;
+  return result.value;
 }
 
 // src/writer/banner.ts
 var BANNER = "// Generated by tako. Do not edit.\n";
 var GITATTRIBUTES = "* linguist-generated=true\n";
 var COMMENTABLE_BASENAMES = /* @__PURE__ */ new Set(["tsconfig.json"]);
-function takesBanner(path5) {
-  if (path5.endsWith(".ts") || path5.endsWith(".tsx")) {
+function takesBanner(path6) {
+  if (path6.endsWith(".ts") || path6.endsWith(".tsx")) {
     return true;
   }
-  const basename = path5.slice(path5.lastIndexOf("/") + 1);
+  const basename = path6.slice(path6.lastIndexOf("/") + 1);
   return COMMENTABLE_BASENAMES.has(basename);
 }
 function applyBanner(files) {
@@ -457,6 +456,10 @@ function applyBanner(files) {
   });
 }
 
+// src/writer/barrel.ts
+import path2 from "path";
+import * as ts from "typescript";
+
 // src/writer/tree.ts
 function contributingGenerators(files) {
   const acc = /* @__PURE__ */ new Map();
@@ -484,65 +487,81 @@ function contributingGenerators(files) {
 }
 
 // src/writer/barrel.ts
-function synthesizeRootBarrels(files, artifactsByGenerator, logger) {
+function synthesizeRootBarrels(files, _artifactsByGenerator, logger) {
   const contributors = contributingGenerators(files);
   const barrels = [];
   for (const namespace of [...contributors.keys()].sort()) {
     const generators = contributors.get(namespace) ?? [];
-    if (artifactsByGenerator && logger) {
-      warnAmbiguousReExports(
-        namespace,
-        generators,
-        artifactsByGenerator,
-        logger
+    const collisions = exportedNameCollisions(namespace, generators, files);
+    const content = [
+      ...generators.map((name) => `export * from './${name}';`),
+      ...[...collisions.entries()].map(
+        ([identifier, owners]) => `export { ${identifier} } from './${owners[0]}';`
+      ),
+      ""
+    ].join("\n");
+    for (const [identifier, owners] of collisions) {
+      logger?.warn(
+        `namespace '${namespace}': identifier '${identifier}' is re-exported by generators [${owners.join(
+          ", "
+        )}]; '${namespace}/index.ts' explicitly re-exports it from '${owners[0]}'. Import a generator subpath to select another declaration.`,
+        { namespace, identifier, generators: owners }
       );
     }
-    const content = generators.map((name) => `export * from './${name}';
-`).join("");
     barrels.push({ path: `${namespace}/index.ts`, content });
   }
   return barrels;
 }
-function warnAmbiguousReExports(namespace, generators, artifactsByGenerator, logger) {
+function exportedNameCollisions(namespace, generators, files) {
+  const sourceFiles = new Map(
+    files.filter((file) => file.path.startsWith(`${namespace}/`)).map((file) => [toVirtualPath(file.path), file.content])
+  );
+  const rootNames = generators.map((generator) => toVirtualPath(`${namespace}/${generator}/index.ts`)).filter((fileName) => sourceFiles.has(fileName));
+  if (rootNames.length < 2) {
+    return /* @__PURE__ */ new Map();
+  }
+  const options = {
+    module: ts.ModuleKind.NodeNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    noLib: true
+  };
+  const host = ts.createCompilerHost(options, true);
+  host.fileExists = (fileName) => sourceFiles.has(fileName);
+  host.readFile = (fileName) => sourceFiles.get(fileName);
+  host.getSourceFile = (fileName, languageVersion) => {
+    const text = sourceFiles.get(fileName);
+    return text === void 0 ? void 0 : ts.createSourceFile(fileName, text, languageVersion, true);
+  };
+  host.directoryExists = (directoryName) => [...sourceFiles.keys()].some(
+    (fileName) => fileName.startsWith(`${directoryName}/`)
+  );
+  const program = ts.createProgram({ rootNames, options, host });
+  const checker = program.getTypeChecker();
   const owners = /* @__PURE__ */ new Map();
-  for (const name of generators) {
-    const artifact = artifactsByGenerator[name];
-    if (!artifact) {
-      continue;
-    }
-    const identifiers = /* @__PURE__ */ new Set();
-    for (const [key, entity] of Object.entries(artifact.entities)) {
-      const dot = key.indexOf(".");
-      const entityNamespace = dot === -1 ? key : key.slice(0, dot);
-      if (entityNamespace !== namespace) {
-        continue;
-      }
-      for (const identifier of Object.values(entity.symbols)) {
-        identifiers.add(identifier);
-      }
-    }
-    for (const identifier of identifiers) {
-      const list = owners.get(identifier) ?? [];
-      list.push(name);
-      owners.set(identifier, list);
-    }
-  }
-  for (const [identifier, list] of owners) {
-    if (list.length > 1) {
-      const sorted = [...list].sort();
-      logger.warn(
-        `namespace '${namespace}': identifier '${identifier}' is re-exported by generators [${sorted.join(
-          ", "
-        )}]; the ambiguous star re-export from '${namespace}/index.ts' will be dropped. Import it from a generator subpath instead.`,
-        { namespace, identifier, generators: sorted }
-      );
+  for (const generator of generators) {
+    const source = program.getSourceFile(
+      toVirtualPath(`${namespace}/${generator}/index.ts`)
+    );
+    if (!source) continue;
+    const module = checker.getSymbolAtLocation(source);
+    if (!module) continue;
+    for (const exported of checker.getExportsOfModule(module)) {
+      const list = owners.get(exported.name) ?? [];
+      list.push(generator);
+      owners.set(exported.name, list);
     }
   }
+  return new Map(
+    [...owners].filter(([, owners2]) => owners2.length > 1).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function toVirtualPath(fileName) {
+  return path2.posix.join("/", fileName);
 }
 
 // src/writer/directory.ts
 import fs from "fs/promises";
-import path2 from "path";
+import path3 from "path";
 var GITATTRIBUTES2 = "* linguist-generated=true\n";
 function sortByPath(entries) {
   return [...entries].sort(
@@ -557,24 +576,24 @@ var directoryWriter = {
         "mode 'dir' requires 'output.dir'"
       );
     }
-    const dir = path2.resolve(output.dir);
+    const dir = path3.resolve(output.dir);
     const planned = files.map((file) => ({
-      path: path2.join(dir, file.path),
+      path: path3.join(dir, file.path),
       content: file.content
     }));
     planned.push({
-      path: path2.join(dir, ".gitattributes"),
+      path: path3.join(dir, ".gitattributes"),
       content: GITATTRIBUTES2
     });
     return sortByPath(planned);
   },
   async write(input) {
     const planned = await this.plan(input);
-    const dir = path2.resolve(input.output.dir);
+    const dir = path3.resolve(input.output.dir);
     await fs.rm(dir, { recursive: true, force: true });
     await fs.mkdir(dir, { recursive: true });
     for (const file of planned) {
-      await fs.mkdir(path2.dirname(file.path), { recursive: true });
+      await fs.mkdir(path3.dirname(file.path), { recursive: true });
       await fs.writeFile(file.path, file.content, "utf8");
     }
     return planned.map((file) => file.path);
@@ -585,7 +604,7 @@ var directoryWriter = {
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import fs2 from "fs/promises";
 import { createRequire } from "module";
-import path4 from "path";
+import path5 from "path";
 
 // src/writer/peers.ts
 function collectPeerDependencies(artifactsByGenerator, files) {
@@ -629,7 +648,7 @@ function collectPeerDependencies(artifactsByGenerator, files) {
 // src/writer/pm.ts
 import { execFile } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var PACKAGE_MANAGERS = [
@@ -649,10 +668,10 @@ function isPackageManager(value) {
   return PACKAGE_MANAGERS.includes(value);
 }
 function* ancestors(startDir) {
-  let dir = path3.resolve(startDir);
+  let dir = path4.resolve(startDir);
   while (true) {
     yield dir;
-    const parent = path3.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir) {
       return;
     }
@@ -665,16 +684,16 @@ function resolvePackageManager(opts) {
   }
   for (const dir of ancestors(opts.startDir)) {
     for (const [file, pm] of LOCKFILES) {
-      if (existsSync(path3.join(dir, file))) {
+      if (existsSync(path4.join(dir, file))) {
         return pm;
       }
     }
-    if (existsSync(path3.join(dir, ".git"))) {
+    if (existsSync(path4.join(dir, ".git"))) {
       break;
     }
   }
   for (const dir of ancestors(opts.startDir)) {
-    const pkgPath = path3.join(dir, "package.json");
+    const pkgPath = path4.join(dir, "package.json");
     if (existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
@@ -687,7 +706,7 @@ function resolvePackageManager(opts) {
       } catch {
       }
     }
-    if (existsSync(path3.join(dir, ".git"))) {
+    if (existsSync(path4.join(dir, ".git"))) {
       break;
     }
   }
@@ -720,7 +739,7 @@ function computePackageLayout({
       "mode 'package' requires 'output.scope'"
     );
   }
-  const packagesDir = path4.resolve(output.packagesDir);
+  const packagesDir = path5.resolve(output.packagesDir);
   const scope = output.scope;
   const scopeSlug = scope.replace(/^@/, "");
   const peersByNamespace = collectPeerDependencies(artifacts ?? {}, files);
@@ -743,17 +762,17 @@ function computePackageLayout({
     const sources = [...byNamespace.get(namespace) ?? []].sort(
       (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
     );
-    const pkgDir = path4.join(packagesDir, `${scopeSlug}-${namespace}`);
+    const pkgDir = path5.join(packagesDir, `${scopeSlug}-${namespace}`);
     const entries = [];
     for (const src of sources) {
       planned.push({
-        path: path4.join(pkgDir, "src", src.path),
+        path: path5.join(pkgDir, "src", src.path),
         content: src.content
       });
       entries.push(`src/${src.path}`);
     }
     planned.push({
-      path: path4.join(pkgDir, "package.json"),
+      path: path5.join(pkgDir, "package.json"),
       content: buildPackageJson(
         scope,
         namespace,
@@ -761,22 +780,22 @@ function computePackageLayout({
       )
     });
     planned.push({
-      path: path4.join(pkgDir, "tsconfig.json"),
+      path: path5.join(pkgDir, "tsconfig.json"),
       content: buildTsconfig(namespace)
     });
     const sortedEntries = entries.sort();
     entriesByNamespace.set(namespace, sortedEntries);
     planned.push({
-      path: path4.join(pkgDir, "tsup.config.ts"),
+      path: path5.join(pkgDir, "tsup.config.ts"),
       content: buildTsupConfig(sortedEntries)
     });
     planned.push({
-      path: path4.join(pkgDir, ".gitattributes"),
+      path: path5.join(pkgDir, ".gitattributes"),
       content: GITATTRIBUTES
     });
   }
   planned.push({
-    path: path4.join(packagesDir, ".gitattributes"),
+    path: path5.join(packagesDir, ".gitattributes"),
     content: `${scopeSlug}-*/** linguist-generated=true
 `
   });
@@ -792,11 +811,11 @@ var packageWriter = {
     assertWorkspaceBaseFiles(packagesDir);
     await fs2.mkdir(packagesDir, { recursive: true });
     for (const namespace of namespaces) {
-      await guardAndReset(path4.join(packagesDir, `${scopeSlug}-${namespace}`));
+      await guardAndReset(path5.join(packagesDir, `${scopeSlug}-${namespace}`));
     }
     const written = [];
     for (const file of planned) {
-      await fs2.mkdir(path4.dirname(file.path), { recursive: true });
+      await fs2.mkdir(path5.dirname(file.path), { recursive: true });
       await fs2.writeFile(file.path, file.content, "utf8");
       written.push(file.path);
     }
@@ -818,13 +837,13 @@ var packageWriter = {
 };
 var TSUP_CONFIG_BASE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
 function assertWorkspaceBaseFiles(packagesDir) {
-  const workspaceRoot = path4.dirname(packagesDir);
+  const workspaceRoot = path5.dirname(packagesDir);
   const missing = [];
-  if (!existsSync2(path4.join(workspaceRoot, "tsconfig.base.json"))) {
+  if (!existsSync2(path5.join(workspaceRoot, "tsconfig.base.json"))) {
     missing.push("tsconfig.base.json");
   }
   const hasTsupBase = TSUP_CONFIG_BASE_EXTENSIONS.some(
-    (ext) => existsSync2(path4.join(workspaceRoot, `tsup.config.base${ext}`))
+    (ext) => existsSync2(path5.join(workspaceRoot, `tsup.config.base${ext}`))
   );
   if (!hasTsupBase) {
     missing.push("tsup.config.base.{ts,js,mjs,cjs}");
@@ -838,7 +857,7 @@ function assertWorkspaceBaseFiles(packagesDir) {
 }
 function isResolvableFrom(specifier, from) {
   try {
-    createRequire(path4.join(from, "noop.js")).resolve(specifier);
+    createRequire(path5.join(from, "noop.js")).resolve(specifier);
     return true;
   } catch {
     return false;
@@ -860,7 +879,7 @@ async function guardAndReset(pkgDir) {
 function hasGeneratedMarker(pkgDir) {
   try {
     const pkg = JSON.parse(
-      readFileSync2(path4.join(pkgDir, "package.json"), "utf8")
+      readFileSync2(path5.join(pkgDir, "package.json"), "utf8")
     );
     return typeof pkg["//"] === "string" && pkg["//"].startsWith("Generated by tako");
   } catch {
@@ -872,7 +891,7 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
   const originalCwd = process.cwd();
   try {
     for (const namespace of namespaces) {
-      const pkgDir = path4.join(packagesDir, `${scopeSlug}-${namespace}`);
+      const pkgDir = path5.join(packagesDir, `${scopeSlug}-${namespace}`);
       process.chdir(pkgDir);
       try {
         await build({
@@ -892,13 +911,13 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
           entry: Object.fromEntries(
             (entriesByNamespace.get(namespace) ?? []).map((entry) => [
               entry.replace(/^src\//, "").replace(/\.ts$/, ""),
-              path4.join(pkgDir, entry)
+              path5.join(pkgDir, entry)
             ])
           ),
-          tsconfig: path4.join(pkgDir, "tsconfig.json"),
+          tsconfig: path5.join(pkgDir, "tsconfig.json"),
           format: ["esm", "cjs"],
           dts: { compilerOptions: { composite: false, incremental: false } },
-          outDir: path4.join(pkgDir, "dist"),
+          outDir: path5.join(pkgDir, "dist"),
           silent: true
         });
       } catch (cause) {
@@ -911,10 +930,10 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
 }
 function findWorkspaceRoot(startDir) {
   for (const dir of ancestors(startDir)) {
-    if (existsSync2(path4.join(dir, "pnpm-workspace.yaml"))) {
+    if (existsSync2(path5.join(dir, "pnpm-workspace.yaml"))) {
       return dir;
     }
-    const pkgPath = path4.join(dir, "package.json");
+    const pkgPath = path5.join(dir, "package.json");
     if (existsSync2(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
@@ -1028,7 +1047,13 @@ async function run(config, opts) {
     }
   }
   checkSignal();
-  const ir = mergeSources(entries);
+  const ir = mergeSources(entries, logger);
+  const cycles = /* @__PURE__ */ new Set();
+  for (const [namespace, source] of Object.entries(ir.sources)) {
+    for (const member of refCycleMembers(source)) {
+      cycles.add(`${namespace}.${member}`);
+    }
+  }
   checkSignal();
   const order = generatorOrder(config.generators);
   const artifacts = {};
@@ -1056,6 +1081,7 @@ async function run(config, opts) {
       const out = await generator.generate({
         ir: view,
         dependencies,
+        cycles,
         logger: childLogger(logger, { generator: name })
       });
       artifacts[name] = out.artifact;