@i18nprune/core 0.1.0

package/dist/runtime/edge.d.ts

@@ -0,0 +1,21 @@
+import { b as RuntimeReadFsPort, R as RuntimeFsPort } from '../fs-BUYD8ZhA.js';
+import { R as RuntimeAdapters } from '../adapters-gp1lXp0T.js';
+import { a as RuntimeSystemPort } from '../capabilities-x74cD2Hu.js';
+import { R as RuntimePathPort } from '../path-Bfn3SAts.js';
+
+declare function createEdgeRuntimeAdapters(input: {
+    fs: RuntimeReadFsPort & Partial<RuntimeFsPort>;
+    cwd?: string;
+    now?: () => number;
+}): RuntimeAdapters;
+
+declare function createEdgeSystemRuntime(input?: {
+    cwd?: string;
+    now?: () => number;
+}): RuntimeSystemPort;
+
+declare const edgePathRuntime: RuntimePathPort;
+
+declare function createEdgeReadFsRuntime(input: RuntimeReadFsPort & Partial<RuntimeFsPort>): RuntimeFsPort;
+
+export { createEdgeReadFsRuntime, createEdgeRuntimeAdapters, createEdgeSystemRuntime, edgePathRuntime };

package/dist/runtime/edge.js

@@ -0,0 +1,87 @@
+// src/runtime/edge/system.ts
+function createEdgeSystemRuntime(input) {
+  return {
+    cwd: () => input?.cwd ?? "/",
+    now: () => input?.now ? input.now() : Date.now()
+  };
+}
+
+// src/runtime/web/path.ts
+function split(value) {
+  return value.replace(/\\/g, "/").split("/").filter((s) => s.length > 0);
+}
+var webPathRuntime = {
+  join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+  dirname: (value) => {
+    const parts = split(value);
+    return parts.length <= 1 ? "/" : `/${parts.slice(0, -1).join("/")}`;
+  },
+  basename: (value, ext) => {
+    const parts = split(value);
+    const base = parts[parts.length - 1] ?? "";
+    return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+  },
+  normalize: (value) => value.replace(/\\/g, "/").replace(/\/+/g, "/"),
+  relative: (_from, to) => to,
+  resolve: (...parts) => webPathRuntime.normalize(parts.join("/")),
+  isAbsolute: (value) => value.startsWith("/")
+};
+
+// src/runtime/edge/path.ts
+var edgePathRuntime = webPathRuntime;
+
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/edge/fs.ts
+function createEdgeReadFsRuntime(input) {
+  return {
+    exists: input.exists,
+    readText: input.readText,
+    statKind: input.statKind ?? ((filePath) => input.exists(filePath) ? "other" : "missing"),
+    listDir: input.listDir ?? (() => []),
+    writeText: input.writeText ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.writeText is not available for this host adapter", "USAGE");
+    }),
+    deleteFile: input.deleteFile ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.deleteFile is not available for this host adapter", "USAGE");
+    }),
+    mkdirp: input.mkdirp ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.mkdirp is not available for this host adapter", "USAGE");
+    })
+  };
+}
+
+// src/runtime/shared/network.ts
+function createAmbientNetworkPort() {
+  return {
+    fetch: globalThis.fetch.bind(globalThis)
+  };
+}
+
+// src/runtime/edge/index.ts
+function createRuntimeAdapters(input) {
+  return {
+    kind: "edge",
+    system: createEdgeSystemRuntime({ cwd: input.cwd, now: input.now }),
+    path: edgePathRuntime,
+    fs: createEdgeReadFsRuntime(input.fs),
+    network: createAmbientNetworkPort()
+  };
+}
+
+// src/runtime/factory/adapters.edge.ts
+function createEdgeRuntimeAdapters(input) {
+  return createRuntimeAdapters(input);
+}
+
+export { createEdgeReadFsRuntime, createEdgeRuntimeAdapters, createEdgeSystemRuntime, edgePathRuntime };

package/dist/runtime/helpers/sync.d.ts

@@ -0,0 +1,16 @@
+import { R as RuntimeFsPort, a as RuntimeDirEntry } from '../../fs-BUYD8ZhA.js';
+
+declare function isThenable(value: unknown): value is PromiseLike<unknown>;
+declare function assertSyncPortResult<T>(value: T | Promise<T>, label: string, at: string): T;
+
+declare function readRuntimeFsTextSync(filePath: string, fs: RuntimeFsPort): string;
+declare function existsRuntimeFsSync(filePath: string, fs: RuntimeFsPort): boolean;
+declare function listRuntimeFsDirSync(dirPath: string, fs: RuntimeFsPort): RuntimeDirEntry[];
+
+/**
+ * Parse JSON from a host `RuntimeFsPort` using a **synchronous** `readText` result.
+ * Used by CLI-style runners that are not async end-to-end yet.
+ */
+declare function readJsonFromRuntimeFsSync(filePath: string, fs: RuntimeFsPort): unknown;
+
+export { assertSyncPortResult, existsRuntimeFsSync, isThenable, listRuntimeFsDirSync, readJsonFromRuntimeFsSync, readRuntimeFsTextSync };

package/dist/runtime/helpers/sync.js

@@ -0,0 +1,117 @@
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/helpers/sync/assert.ts
+function isThenable(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function assertSyncPortResult(value, label, at) {
+  if (isThenable(value)) {
+    throw new I18nPruneError(
+      `Synchronous ${label} requires a plain value (got a Promise at ${at})`,
+      "USAGE"
+    );
+  }
+  return value;
+}
+
+// src/runtime/helpers/sync/fs.ts
+function readRuntimeFsTextSync(filePath, fs) {
+  return assertSyncPortResult(fs.readText(filePath), "fs.readText", filePath);
+}
+function existsRuntimeFsSync(filePath, fs) {
+  return assertSyncPortResult(fs.exists(filePath), "fs.exists", filePath);
+}
+function listRuntimeFsDirSync(dirPath, fs) {
+  return assertSyncPortResult(fs.listDir(dirPath), "fs.listDir", dirPath);
+}
+
+// src/shared/constants/issueCodes.ts
+var ISSUE_IO_READ_FAILED = "i18nprune.io.read_failed";
+
+// src/shared/json/parse.ts
+var I18nPruneJsonParseError = class extends I18nPruneError {
+  filePath;
+  line;
+  column;
+  offset;
+  constructor(input) {
+    const options = input.issueCode !== void 0 ? { cause: input.cause, issueCode: input.issueCode } : { cause: input.cause };
+    super(input.message, input.code, options);
+    this.name = "I18nPruneJsonParseError";
+    this.filePath = input.filePath;
+    this.line = input.location.line;
+    this.column = input.location.column;
+    this.offset = input.location.offset;
+  }
+};
+function locationFromOffset(text, offset) {
+  let line = 1;
+  let column = 1;
+  const capped = Math.max(0, Math.min(offset, text.length));
+  for (let i = 0; i < capped; i += 1) {
+    if (text.charCodeAt(i) === 10) {
+      line += 1;
+      column = 1;
+    } else {
+      column += 1;
+    }
+  }
+  return { line, column, offset };
+}
+function getJsonParseLocation(error, text) {
+  const message = error instanceof Error ? error.message : String(error);
+  const positionMatch = /\bposition\s+(\d+)\b/i.exec(message);
+  if (positionMatch?.[1]) {
+    return locationFromOffset(text, Number.parseInt(positionMatch[1], 10));
+  }
+  const lineColumnMatch = /\bline\s+(\d+)\s+column\s+(\d+)\b/i.exec(message);
+  if (lineColumnMatch?.[1] && lineColumnMatch[2]) {
+    return {
+      line: Number.parseInt(lineColumnMatch[1], 10),
+      column: Number.parseInt(lineColumnMatch[2], 10)
+    };
+  }
+  return {};
+}
+function formatJsonParseMessage(filePath, location, cause) {
+  const subject = filePath ? `Invalid JSON in ${filePath}` : "Invalid JSON";
+  const at = location.line !== void 0 && location.column !== void 0 ? ` at line ${String(location.line)}, column ${String(location.column)}` : location.offset !== void 0 ? ` at offset ${String(location.offset)}` : "";
+  const detail = cause instanceof Error ? cause.message : String(cause);
+  return `${subject}${at}: ${detail}`;
+}
+function parseJsonText(text, options = {}) {
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    const location = getJsonParseLocation(cause, text);
+    throw new I18nPruneJsonParseError({
+      message: formatJsonParseMessage(options.filePath, location, cause),
+      code: options.code ?? "IO",
+      cause,
+      location,
+      ...options.issueCode !== void 0 ? { issueCode: options.issueCode } : {},
+      ...options.filePath !== void 0 ? { filePath: options.filePath } : {}
+    });
+  }
+}
+
+// src/runtime/helpers/sync/readJson.ts
+function readJsonFromRuntimeFsSync(filePath, fs) {
+  return parseJsonText(readRuntimeFsTextSync(filePath, fs), {
+    filePath,
+    code: "IO",
+    issueCode: ISSUE_IO_READ_FAILED
+  });
+}
+
+export { assertSyncPortResult, existsRuntimeFsSync, isThenable, listRuntimeFsDirSync, readJsonFromRuntimeFsSync, readRuntimeFsTextSync };

package/dist/runtime/node.d.ts

@@ -0,0 +1,24 @@
+import { a as RuntimeSystemPort } from '../capabilities-x74cD2Hu.js';
+import { R as RuntimePathPort } from '../path-Bfn3SAts.js';
+import { R as RuntimeFsPort, b as RuntimeReadFsPort } from '../fs-BUYD8ZhA.js';
+import { R as RuntimeAdapters, a as RuntimeKind } from '../adapters-gp1lXp0T.js';
+
+declare const nodeSystemRuntime: RuntimeSystemPort;
+
+declare const nodePathRuntime: RuntimePathPort;
+
+declare const nodeReadFsRuntime: RuntimeFsPort;
+
+declare function createNodeRuntimeAdapters(): RuntimeAdapters;
+
+declare function createRuntimeAdaptersForKind(kind: 'node', input?: {
+    cwd?: string;
+    now?: () => number;
+}): RuntimeAdapters;
+declare function createRuntimeAdaptersForKind(kind: Exclude<RuntimeKind, 'node'>, input: {
+    fs: RuntimeReadFsPort & Partial<RuntimeFsPort>;
+    cwd?: string;
+    now?: () => number;
+}): RuntimeAdapters;
+
+export { createNodeRuntimeAdapters, createRuntimeAdaptersForKind, nodePathRuntime, nodeReadFsRuntime, nodeSystemRuntime };

package/dist/runtime/node.js

@@ -0,0 +1,204 @@
+import path from 'path';
+import fs from 'fs';
+
+// src/runtime/node/system.ts
+var nodeSystemRuntime = {
+  cwd: () => process.cwd(),
+  now: () => Date.now()
+};
+var nodePathRuntime = {
+  join: (...parts) => path.join(...parts),
+  dirname: (value) => path.dirname(value),
+  basename: (value, ext) => path.basename(value, ext),
+  normalize: (value) => path.normalize(value),
+  relative: (from, to) => path.relative(from, to),
+  resolve: (...parts) => path.resolve(...parts),
+  isAbsolute: (value) => path.isAbsolute(value)
+};
+var nodeReadFsRuntime = {
+  exists: (filePath) => fs.existsSync(filePath),
+  readText: (filePath) => fs.readFileSync(filePath, "utf8"),
+  statKind: (filePath) => {
+    if (!fs.existsSync(filePath)) return "missing";
+    const st = fs.statSync(filePath);
+    if (st.isFile()) return "file";
+    if (st.isDirectory()) return "directory";
+    return "other";
+  },
+  listDir: (dirPath) => fs.readdirSync(dirPath, { withFileTypes: true }).map((entry) => {
+    const full = path.join(dirPath, entry.name);
+    if (entry.isFile()) return { name: entry.name, kind: "file" };
+    if (entry.isDirectory()) return { name: entry.name, kind: "directory" };
+    if (entry.isSymbolicLink()) {
+      try {
+        const st = fs.statSync(full);
+        if (st.isDirectory()) return { name: entry.name, kind: "directory" };
+        if (st.isFile()) return { name: entry.name, kind: "file" };
+      } catch {
+      }
+    }
+    return { name: entry.name, kind: "other" };
+  }),
+  writeText: (filePath, content) => fs.writeFileSync(filePath, content, "utf8"),
+  deleteFile: (filePath) => fs.unlinkSync(filePath),
+  mkdirp: (dirPath) => {
+    fs.mkdirSync(path.resolve(dirPath), { recursive: true });
+  },
+  realpath: (filePath) => fs.realpathSync.native(filePath)
+};
+
+// src/runtime/shared/network.ts
+function createAmbientNetworkPort() {
+  return {
+    fetch: globalThis.fetch.bind(globalThis)
+  };
+}
+
+// src/runtime/node/index.ts
+function createRuntimeAdapters() {
+  return {
+    kind: "node",
+    system: nodeSystemRuntime,
+    path: nodePathRuntime,
+    fs: nodeReadFsRuntime,
+    network: createAmbientNetworkPort()
+  };
+}
+
+// src/runtime/factory/adapters.node.ts
+function createNodeRuntimeAdapters() {
+  return createRuntimeAdapters();
+}
+
+// src/runtime/web/system.ts
+function createWebSystemRuntime(input) {
+  return {
+    cwd: () => input?.cwd ?? "/",
+    now: () => input?.now ? input.now() : Date.now()
+  };
+}
+
+// src/runtime/web/path.ts
+function split(value) {
+  return value.replace(/\\/g, "/").split("/").filter((s) => s.length > 0);
+}
+var webPathRuntime = {
+  join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+  dirname: (value) => {
+    const parts = split(value);
+    return parts.length <= 1 ? "/" : `/${parts.slice(0, -1).join("/")}`;
+  },
+  basename: (value, ext) => {
+    const parts = split(value);
+    const base = parts[parts.length - 1] ?? "";
+    return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+  },
+  normalize: (value) => value.replace(/\\/g, "/").replace(/\/+/g, "/"),
+  relative: (_from, to) => to,
+  resolve: (...parts) => webPathRuntime.normalize(parts.join("/")),
+  isAbsolute: (value) => value.startsWith("/")
+};
+
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/web/fs.ts
+function createWebReadFsRuntime(input) {
+  return {
+    exists: input.exists,
+    readText: input.readText,
+    statKind: input.statKind ?? ((filePath) => input.exists(filePath) ? "other" : "missing"),
+    listDir: input.listDir ?? (() => []),
+    writeText: input.writeText ?? (() => {
+      throw new I18nPruneError("Web runtime fs.writeText is not available for this host adapter", "USAGE");
+    }),
+    deleteFile: input.deleteFile ?? (() => {
+      throw new I18nPruneError("Web runtime fs.deleteFile is not available for this host adapter", "USAGE");
+    }),
+    mkdirp: input.mkdirp ?? (() => {
+      throw new I18nPruneError("Web runtime fs.mkdirp is not available for this host adapter", "USAGE");
+    })
+  };
+}
+
+// src/runtime/web/index.ts
+function createRuntimeAdapters2(input) {
+  return {
+    kind: "web",
+    system: createWebSystemRuntime({ cwd: input.cwd, now: input.now }),
+    path: webPathRuntime,
+    fs: createWebReadFsRuntime(input.fs),
+    network: createAmbientNetworkPort()
+  };
+}
+
+// src/runtime/factory/adapters.web.ts
+function createWebRuntimeAdapters(input) {
+  return createRuntimeAdapters2(input);
+}
+
+// src/runtime/edge/system.ts
+function createEdgeSystemRuntime(input) {
+  return {
+    cwd: () => input?.cwd ?? "/",
+    now: () => input?.now ? input.now() : Date.now()
+  };
+}
+
+// src/runtime/edge/path.ts
+var edgePathRuntime = webPathRuntime;
+
+// src/runtime/edge/fs.ts
+function createEdgeReadFsRuntime(input) {
+  return {
+    exists: input.exists,
+    readText: input.readText,
+    statKind: input.statKind ?? ((filePath) => input.exists(filePath) ? "other" : "missing"),
+    listDir: input.listDir ?? (() => []),
+    writeText: input.writeText ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.writeText is not available for this host adapter", "USAGE");
+    }),
+    deleteFile: input.deleteFile ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.deleteFile is not available for this host adapter", "USAGE");
+    }),
+    mkdirp: input.mkdirp ?? (() => {
+      throw new I18nPruneError("Edge runtime fs.mkdirp is not available for this host adapter", "USAGE");
+    })
+  };
+}
+
+// src/runtime/edge/index.ts
+function createRuntimeAdapters3(input) {
+  return {
+    kind: "edge",
+    system: createEdgeSystemRuntime({ cwd: input.cwd, now: input.now }),
+    path: edgePathRuntime,
+    fs: createEdgeReadFsRuntime(input.fs),
+    network: createAmbientNetworkPort()
+  };
+}
+
+// src/runtime/factory/adapters.edge.ts
+function createEdgeRuntimeAdapters(input) {
+  return createRuntimeAdapters3(input);
+}
+
+// src/runtime/factory/adapters.dispatch.ts
+function createRuntimeAdaptersForKind(kind, input) {
+  if (kind === "node") return createNodeRuntimeAdapters();
+  if (!input?.fs) {
+    throw new Error(`Runtime "${kind}" requires fs adapter input`);
+  }
+  return kind === "web" ? createWebRuntimeAdapters({ fs: input.fs, cwd: input.cwd, now: input.now }) : createEdgeRuntimeAdapters({ fs: input.fs, cwd: input.cwd, now: input.now });
+}
+
+export { createNodeRuntimeAdapters, createRuntimeAdaptersForKind, nodePathRuntime, nodeReadFsRuntime, nodeSystemRuntime };

package/dist/runtime/web.d.ts

@@ -0,0 +1,21 @@
+import { b as RuntimeReadFsPort, R as RuntimeFsPort } from '../fs-BUYD8ZhA.js';
+import { R as RuntimeAdapters } from '../adapters-gp1lXp0T.js';
+import { a as RuntimeSystemPort } from '../capabilities-x74cD2Hu.js';
+import { R as RuntimePathPort } from '../path-Bfn3SAts.js';
+
+declare function createWebRuntimeAdapters(input: {
+    fs: RuntimeReadFsPort & Partial<RuntimeFsPort>;
+    cwd?: string;
+    now?: () => number;
+}): RuntimeAdapters;
+
+declare function createWebSystemRuntime(input?: {
+    cwd?: string;
+    now?: () => number;
+}): RuntimeSystemPort;
+
+declare const webPathRuntime: RuntimePathPort;
+
+declare function createWebReadFsRuntime(input: RuntimeReadFsPort & Partial<RuntimeFsPort>): RuntimeFsPort;
+
+export { createWebReadFsRuntime, createWebRuntimeAdapters, createWebSystemRuntime, webPathRuntime };

package/dist/runtime/web.js

@@ -0,0 +1,84 @@
+// src/runtime/web/system.ts
+function createWebSystemRuntime(input) {
+  return {
+    cwd: () => input?.cwd ?? "/",
+    now: () => input?.now ? input.now() : Date.now()
+  };
+}
+
+// src/runtime/web/path.ts
+function split(value) {
+  return value.replace(/\\/g, "/").split("/").filter((s) => s.length > 0);
+}
+var webPathRuntime = {
+  join: (...parts) => parts.join("/").replace(/\/+/g, "/"),
+  dirname: (value) => {
+    const parts = split(value);
+    return parts.length <= 1 ? "/" : `/${parts.slice(0, -1).join("/")}`;
+  },
+  basename: (value, ext) => {
+    const parts = split(value);
+    const base = parts[parts.length - 1] ?? "";
+    return ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+  },
+  normalize: (value) => value.replace(/\\/g, "/").replace(/\/+/g, "/"),
+  relative: (_from, to) => to,
+  resolve: (...parts) => webPathRuntime.normalize(parts.join("/")),
+  isAbsolute: (value) => value.startsWith("/")
+};
+
+// src/shared/errors/internal.ts
+var I18nPruneError = class extends Error {
+  code;
+  issueCode;
+  constructor(message, code, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "I18nPruneError";
+    this.code = code;
+    this.issueCode = options?.issueCode;
+  }
+};
+
+// src/runtime/web/fs.ts
+function createWebReadFsRuntime(input) {
+  return {
+    exists: input.exists,
+    readText: input.readText,
+    statKind: input.statKind ?? ((filePath) => input.exists(filePath) ? "other" : "missing"),
+    listDir: input.listDir ?? (() => []),
+    writeText: input.writeText ?? (() => {
+      throw new I18nPruneError("Web runtime fs.writeText is not available for this host adapter", "USAGE");
+    }),
+    deleteFile: input.deleteFile ?? (() => {
+      throw new I18nPruneError("Web runtime fs.deleteFile is not available for this host adapter", "USAGE");
+    }),
+    mkdirp: input.mkdirp ?? (() => {
+      throw new I18nPruneError("Web runtime fs.mkdirp is not available for this host adapter", "USAGE");
+    })
+  };
+}
+
+// src/runtime/shared/network.ts
+function createAmbientNetworkPort() {
+  return {
+    fetch: globalThis.fetch.bind(globalThis)
+  };
+}
+
+// src/runtime/web/index.ts
+function createRuntimeAdapters(input) {
+  return {
+    kind: "web",
+    system: createWebSystemRuntime({ cwd: input.cwd, now: input.now }),
+    path: webPathRuntime,
+    fs: createWebReadFsRuntime(input.fs),
+    network: createAmbientNetworkPort()
+  };
+}
+
+// src/runtime/factory/adapters.web.ts
+function createWebRuntimeAdapters(input) {
+  return createRuntimeAdapters(input);
+}
+
+export { createWebReadFsRuntime, createWebRuntimeAdapters, createWebSystemRuntime, webPathRuntime };