hanzio 2.2.0 → 3.1.0

package/dist/index-6ragggbs.js

@@ -0,0 +1,473 @@
+import {
+  defOf,
+  unwrapOnce
+} from "./index-ww09bm49.js";
+
+// src/cli/index.ts
+import { parseArgs } from "node:util";
+
+// src/cli/fields.ts
+import { z } from "zod";
+class UsageError extends Error {
+}
+var kebab = (key) => key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+function fieldsOf(schema) {
+  if (!schema)
+    return [];
+  return Object.entries(schema.shape).map(([key, child]) => toField(key, child));
+}
+function toField(key, schema) {
+  const metas = [];
+  let optional = false;
+  let hasDefault = false;
+  let defaultValue;
+  let current = schema;
+  for (;; ) {
+    const meta = z.globalRegistry.get(current);
+    if (meta)
+      metas.unshift(meta);
+    const def = defOf(current);
+    if (def.type === "optional")
+      optional = true;
+    if ((def.type === "default" || def.type === "prefault") && !hasDefault) {
+      hasDefault = true;
+      defaultValue = def.defaultValue;
+    }
+    const inner = unwrapOnce(def);
+    if (!inner)
+      break;
+    current = inner;
+  }
+  const meta = Object.assign({}, ...metas);
+  let def = defOf(current);
+  const multiple = def.type === "array";
+  if (def.type === "array") {
+    let element = def.element;
+    for (let inner = unwrapOnce(defOf(element));inner; ) {
+      element = inner;
+      inner = unwrapOnce(defOf(element));
+    }
+    def = defOf(element);
+  }
+  const alias = meta.alias;
+  if (alias !== undefined && (typeof alias !== "string" || alias.length !== 1))
+    throw new Error(`hanzio/cli: alias ${JSON.stringify(alias)} of "${key}" must be one character`);
+  return {
+    key,
+    flag: kebab(key),
+    kind: def.type === "boolean" ? "boolean" : def.type === "number" ? "number" : "string",
+    multiple,
+    positional: meta.positional === true,
+    optional,
+    hasDefault,
+    defaultValue,
+    description: typeof meta.description === "string" ? meta.description : undefined,
+    alias,
+    env: typeof meta.env === "string" ? meta.env : undefined,
+    choices: def.type === "enum" ? Object.values(def.entries).map(String) : def.type === "literal" ? def.values.map(String) : undefined
+  };
+}
+function coerce(field, value) {
+  if (typeof value !== "string")
+    return value;
+  if (field.kind === "number" && value.trim() !== "") {
+    const number = Number(value);
+    return Number.isNaN(number) ? value : number;
+  }
+  if (field.kind === "boolean") {
+    if (value === "true" || value === "1")
+      return true;
+    if (value === "false" || value === "0" || value === "")
+      return false;
+  }
+  return value;
+}
+function readFields(fields, values, positionals, env) {
+  const result = {};
+  const queue = [...positionals];
+  for (const field of fields) {
+    let raw;
+    if (field.positional)
+      raw = field.multiple ? queue.length ? queue.splice(0) : undefined : queue.shift();
+    else
+      raw = values[field.flag];
+    if (raw === undefined && field.env && env[field.env] !== undefined) {
+      const value = env[field.env];
+      raw = field.multiple ? [value] : value;
+    }
+    if (raw === undefined) {
+      if (field.optional || field.hasDefault)
+        continue;
+      if (field.multiple)
+        raw = [];
+      else if (field.kind === "boolean")
+        raw = false;
+      else
+        continue;
+    }
+    result[field.key] = Array.isArray(raw) ? raw.map((item) => coerce(field, item)) : coerce(field, raw);
+  }
+  if (queue.length)
+    throw new UsageError(`Unexpected argument "${queue[0]}"`);
+  return result;
+}
+function fieldLabel(field) {
+  if (field.positional)
+    return field.multiple ? `<${field.flag}...>` : field.optional || field.hasDefault ? `[${field.flag}]` : `<${field.flag}>`;
+  const name = field.kind === "boolean" && field.defaultValue === true ? `--[no-]${field.flag}` : `--${field.flag}`;
+  const value = field.kind === "boolean" ? "" : ` <${field.choices?.join("|") ?? field.kind}>${field.multiple ? "..." : ""}`;
+  return `${field.alias ? `-${field.alias}, ` : ""}${name}${value}`;
+}
+function fieldHelp(field) {
+  const showDefault = field.hasDefault && field.defaultValue !== undefined && !(field.kind === "boolean" && field.defaultValue === false);
+  return [
+    field.description,
+    showDefault && `(default: ${JSON.stringify(field.defaultValue)})`,
+    field.env && `[env: ${field.env}]`
+  ].filter(Boolean).join(" ");
+}
+function closest(input, candidates) {
+  let best;
+  let bestDistance = Math.max(2, Math.floor(input.length / 3)) + 1;
+  for (const candidate of candidates) {
+    const distance = candidate.startsWith(input) ? 1 : levenshtein(input, candidate);
+    if (distance < bestDistance) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function levenshtein(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1;j <= b.length; j++)
+      current[j] = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+
+// src/cli/index.ts
+var commandKey = Symbol.for("hanzio/cli/command");
+
+class CliError2 extends Error {
+  exitCode;
+  constructor(message, options) {
+    super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "CliError";
+    this.exitCode = options?.exitCode ?? 1;
+  }
+}
+function defineCommand2(definition) {
+  return { ...definition, [commandKey]: true };
+}
+var isCommand = (node) => typeof node === "object" && node !== null && (commandKey in node);
+async function loadCommand(node) {
+  if (typeof node !== "function" && !node.load)
+    return node;
+  const loaded = await (typeof node === "function" ? node() : node.load?.());
+  const command = isCommand(loaded) ? loaded : loaded?.default;
+  if (!isCommand(command))
+    throw new Error("hanzio/cli: a lazy command must resolve to defineCommand() or a module that default-exports one");
+  return loadCommand(command);
+}
+function listCommands(group, prefix = []) {
+  return Object.entries(group).flatMap(([name, node]) => typeof node === "function" || isCommand(node) ? [
+    [
+      [...prefix, name],
+      typeof node === "function" ? undefined : node.description
+    ]
+  ] : listCommands(node, [...prefix, name]));
+}
+function table(rows) {
+  const width = Math.max(...rows.map(([left]) => left.length));
+  return rows.map(([left, right]) => `  ${left.padEnd(width)}  ${right ?? ""}`.trimEnd()).join(`
+`);
+}
+var optionRows = (fields) => fields.map((field) => [fieldLabel(field), fieldHelp(field)]);
+var helpRow = ["-h, --help", "Show help"];
+function defineCli2(config) {
+  const root = config.commands;
+  const builtIn = (group) => group === root && !Object.hasOwn(group, "completion");
+  const versionRow = config.version ? [["--version", "Show version"]] : [];
+  function groupHelp(group, path, globals) {
+    const usage = [config.name, ...path].join(" ");
+    const commands = listCommands(group).map(([names, description]) => [
+      names.join(" "),
+      description
+    ]);
+    if (builtIn(group))
+      commands.push([
+        "completion <bash|zsh>",
+        "Print a shell completion script"
+      ]);
+    return [
+      ...path.length ? [] : [
+        [config.name, config.version].filter(Boolean).join(" "),
+        ...config.description ? [config.description] : [],
+        ""
+      ],
+      `Usage: ${usage} <command> [options]`,
+      "",
+      "Commands:",
+      table(commands),
+      "",
+      "Options:",
+      table([
+        ...optionRows(globals),
+        helpRow,
+        ...path.length ? [] : versionRow
+      ]),
+      "",
+      `Run "${usage} <command> --help" for a command's options.`
+    ].join(`
+`);
+  }
+  function commandHelp(command, path, fields, globals) {
+    const positionals = fields.filter((field) => field.positional);
+    const options = fields.filter((field) => !field.positional);
+    const sections = [
+      `Usage: ${[config.name, ...path, ...positionals.map(fieldLabel)].join(" ")} [options]`
+    ];
+    const description = command.description ?? config.description;
+    if (description)
+      sections.push(description);
+    if (positionals.length)
+      sections.push(`Arguments:
+${table(optionRows(positionals))}`);
+    sections.push(`Options:
+${table([
+      ...optionRows(options),
+      helpRow,
+      ...path.length ? [] : versionRow
+    ])}`);
+    if (globals.length)
+      sections.push(`Global options:
+${table(optionRows(globals))}`);
+    return sections.join(`
+
+`);
+  }
+  async function completion(shell, globals) {
+    const fn = `_${config.name.replace(/\W/g, "_")}_completion`;
+    const flags = (fields) => [...fields, ...globals].filter((field) => !field.positional).map((field) => `--${field.flag}`);
+    const cases = [];
+    const visit = async (node, path) => {
+      if (typeof node === "function" || isCommand(node)) {
+        const command = await loadCommand(node);
+        cases.push([
+          path.join(" "),
+          command.raw ? [] : [...flags(fieldsOf(command.input)), "--help"]
+        ]);
+        return;
+      }
+      for (const [name, child] of Object.entries(node))
+        await visit(child, [...path, name]);
+      const names = Object.keys(node);
+      if (builtIn(node))
+        names.push("completion");
+      cases.push([path.join(" "), [...names, ...flags([]), "--help"]]);
+    };
+    await visit(root, []);
+    cases.sort(([a], [b]) => b.length - a.length);
+    const branches = cases.map(([path, words]) => path ? `		"${path}"|"${path} "*) opts="${words.join(" ")}" ;;` : `		*) opts="${words.join(" ")}" ;;`);
+    const script = `${fn}() {
+	local cur="\${COMP_WORDS[COMP_CWORD]}" words="" word opts
+	for word in "\${COMP_WORDS[@]:1:COMP_CWORD-1}"; do
+		[[ $word == -* ]] || words="$words $word"
+	done
+	case "\${words# }" in
+${branches.join(`
+`)}
+	esac
+	COMPREPLY=($(compgen -W "$opts" -- "$cur"))
+}
+complete -F ${fn} ${config.name}
+`;
+    if (shell === "bash")
+      return script;
+    if (shell === "zsh")
+      return `autoload -U +X bashcompinit && bashcompinit
+${script}`;
+    throw new UsageError(`Unknown shell "${shell}": use bash or zsh`);
+  }
+  return {
+    name: config.name,
+    async run(argv = process.argv.slice(2), io = {}) {
+      const stdout = io.stdout ?? process.stdout;
+      const stderr = io.stderr ?? process.stderr;
+      const env = io.env ?? process.env;
+      let usage = config.name;
+      let json = false;
+      try {
+        const globalFields = fieldsOf(config.globals);
+        const positional = globalFields.find((field) => field.positional);
+        if (positional)
+          throw new Error(`hanzio/cli: global "${positional.key}" can't be positional`);
+        const valueFlags = new Set(globalFields.filter((field) => field.kind !== "boolean").flatMap((field) => [
+          `--${field.flag}`,
+          ...field.alias ? [`-${field.alias}`] : []
+        ]));
+        const isHelp = (token) => token === "--help" || token === "-h";
+        let node = root;
+        const path = [];
+        const pre = [];
+        let index = 0;
+        while (typeof node !== "function" && !isCommand(node)) {
+          const group = node;
+          const token = argv[index];
+          if (token === undefined || token === "--") {
+            if (pre.some(isHelp)) {
+              stdout.write(`${groupHelp(group, path, globalFields)}
+`);
+              return 0;
+            }
+            if (!path.length && config.version && pre.includes("--version")) {
+              stdout.write(`${config.version}
+`);
+              return 0;
+            }
+            throw new UsageError(`${path.length ? `${usage}: missing` : "Missing"} command
+
+${groupHelp(group, path, globalFields)}`);
+          }
+          index++;
+          if (token.startsWith("-") && token !== "-") {
+            pre.push(token);
+            if (valueFlags.has(token) && argv[index] !== undefined)
+              pre.push(argv[index++]);
+            continue;
+          }
+          if (token === "completion" && builtIn(group)) {
+            const [shell = "bash"] = argv.slice(index);
+            stdout.write(await completion(shell, globalFields));
+            return 0;
+          }
+          const child = Object.hasOwn(group, token) ? group[token] : undefined;
+          if (!child) {
+            const names = Object.keys(group);
+            const guess = closest(token, names);
+            throw new UsageError(`Unknown command "${[...path, token].join(" ")}".${guess ? ` Did you mean "${[...path, guess].join(" ")}"?` : ` Commands: ${names.join(", ")}`}`);
+          }
+          node = child;
+          path.push(token);
+          usage = `${usage} ${token}`;
+        }
+        const command = await loadCommand(node);
+        const rest = argv.slice(index);
+        const fields = command.raw ? [] : fieldsOf(command.input);
+        const dash = rest.indexOf("--");
+        const tokens = command.raw ? pre : [...pre, ...dash < 0 ? rest : rest.slice(0, dash)];
+        if (!command.raw && tokens.some(isHelp)) {
+          stdout.write(`${commandHelp(command, path, fields, globalFields)}
+`);
+          return 0;
+        }
+        if (!path.length && config.version && tokens.includes("--version")) {
+          stdout.write(`${config.version}
+`);
+          return 0;
+        }
+        const options = {};
+        for (const field of [...globalFields, ...fields]) {
+          if (field.positional)
+            continue;
+          if (field.flag === "help" || Object.hasOwn(options, field.flag))
+            throw new Error(`hanzio/cli: --${field.flag} is declared twice`);
+          options[field.flag] = {
+            type: field.kind === "boolean" ? "boolean" : "string",
+            multiple: field.multiple,
+            ...field.alias ? { short: field.alias } : {}
+          };
+        }
+        let parsed;
+        try {
+          parsed = parseArgs({
+            args: tokens,
+            options,
+            allowPositionals: true,
+            allowNegative: true,
+            strict: true
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          const unknown = /^Unknown option '(-[^']*)'/.exec(message)?.[1];
+          if (!unknown)
+            throw new UsageError(message.split(". ")[0] ?? message);
+          const guess = closest(unknown.replace(/^--?/, ""), Object.keys(options));
+          throw new UsageError(`Unknown option ${unknown}.${guess ? ` Did you mean --${guess}?` : ""}`);
+        }
+        const issues = [];
+        const validate = async (schema, fields, positionals) => {
+          const raw = readFields(fields, parsed.values, positionals, env);
+          if (!schema)
+            return raw;
+          const result = await schema.safeParseAsync(raw);
+          if (result.success)
+            return result.data;
+          for (const issue of result.error.issues) {
+            const field = fields.find((field) => field.key === issue.path[0]);
+            const label = field ? field.positional ? `<${field.flag}>` : `--${field.flag}` : issue.path.join(".");
+            issues.push(label ? `${label}: ${issue.message}` : issue.message);
+          }
+          return raw;
+        };
+        const globals = await validate(config.globals, globalFields, []);
+        const input = await validate(command.raw ? undefined : command.input, fields, parsed.positionals);
+        if (issues.length)
+          throw new UsageError(issues.join(`
+`));
+        json = input.json === true || globals.json === true;
+        const context = await config.context?.(globals);
+        await config.guard?.({
+          path,
+          input,
+          globals,
+          context
+        });
+        const ctx = {
+          context,
+          globals,
+          path,
+          argv: rest,
+          passthrough: dash < 0 ? [] : rest.slice(dash + 1),
+          json,
+          stdout,
+          stderr,
+          env,
+          exitCode: 0
+        };
+        const run = command.run;
+        const result = await run(input, ctx);
+        const output = command.output ?? printResult;
+        await output(result, ctx);
+        return ctx.exitCode;
+      } catch (error) {
+        if (error instanceof UsageError) {
+          stderr.write(`${error.message}
+Run "${usage} --help" for usage.
+`);
+          return 2;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        if (json)
+          stderr.write(`${JSON.stringify({ error: message })}
+`);
+        else
+          stderr.write(`${error instanceof Error && !(error instanceof CliError2) ? error.stack ?? message : message}
+`);
+        return error instanceof CliError2 ? error.exitCode : 1;
+      }
+    }
+  };
+}
+function printResult(result, ctx) {
+  if (result === undefined)
+    return;
+  ctx.stdout.write(`${ctx.json ? JSON.stringify(result) : typeof result === "string" ? result : JSON.stringify(result, null, 2)}
+`);
+}
+
+export { CliError2, defineCommand2, defineCli2 };

package/dist/index-mq2qgc20.js

@@ -0,0 +1,116 @@
+// src/storage/index.ts
+function createMemoryStorage2() {
+  const map = new Map;
+  return {
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => {
+      map.set(key, String(value));
+    },
+    removeItem: (key) => {
+      map.delete(key);
+    }
+  };
+}
+var sharedMemoryStorage;
+function defaultStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    if (storage)
+      return storage;
+  } catch {}
+  sharedMemoryStorage ??= createMemoryStorage2();
+  return sharedMemoryStorage;
+}
+function createCodec(options) {
+  const {
+    fallback,
+    parse = (raw) => raw,
+    serialize = JSON.stringify,
+    deserialize = JSON.parse
+  } = options;
+  return {
+    serialize,
+    decode(raw) {
+      if (raw === null)
+        return fallback;
+      try {
+        return parse(deserialize(raw));
+      } catch {
+        return fallback;
+      }
+    }
+  };
+}
+function createStorageItem2(options) {
+  const { key, fallback, storage = defaultStorage() } = options;
+  const { serialize, decode } = createCodec(options);
+  let mirror;
+  const write = (value, action) => {
+    try {
+      action();
+      mirror = undefined;
+    } catch {
+      mirror = { value };
+    }
+  };
+  const get = () => {
+    if (mirror)
+      return mirror.value;
+    try {
+      return decode(storage.getItem(key));
+    } catch {
+      return fallback;
+    }
+  };
+  return {
+    key,
+    get,
+    set: (value) => write(value, () => storage.setItem(key, serialize(value))),
+    remove: () => write(fallback, () => storage.removeItem(key)),
+    subscribe(listener) {
+      const target = globalThis;
+      if (!target.addEventListener || !target.removeEventListener) {
+        return () => {};
+      }
+      const onStorage = (event) => {
+        if (event.storageArea !== storage)
+          return;
+        if (event.key !== key && event.key !== null)
+          return;
+        mirror = undefined;
+        listener(get());
+      };
+      target.addEventListener("storage", onStorage);
+      return () => target.removeEventListener?.("storage", onStorage);
+    }
+  };
+}
+function createAsyncStorageItem2(options) {
+  const { key, fallback, storage } = options;
+  const { serialize, decode } = createCodec(options);
+  let mirror;
+  const write = async (value, action) => {
+    try {
+      await action();
+      mirror = undefined;
+    } catch {
+      mirror = { value };
+    }
+  };
+  return {
+    key,
+    async get() {
+      if (mirror)
+        return mirror.value;
+      try {
+        return decode(await storage.getItem(key));
+      } catch {
+        return fallback;
+      }
+    },
+    set: (value) => write(value, () => storage.setItem(key, serialize(value))),
+    remove: () => write(fallback, () => storage.removeItem(key))
+  };
+}
+
+export { createMemoryStorage2, createStorageItem2, createAsyncStorageItem2 };

package/dist/index-najbyzpr.js

@@ -0,0 +1,99 @@
+// src/i18n/locales.ts
+var normalizeTag = (tag) => tag.trim().replaceAll("_", "-").toLowerCase();
+function defineLocales2(options) {
+  const { locales: info, defaultLocale, aliases = {} } = options;
+  const locales = Object.keys(info);
+  const lookup = new Map;
+  for (const locale of locales)
+    lookup.set(normalizeTag(locale), locale);
+  for (const locale of locales) {
+    const tag = normalizeTag(info[locale].tag);
+    if (!lookup.has(tag))
+      lookup.set(tag, locale);
+  }
+  const aliasLookup = new Map;
+  for (const [alias, locale] of Object.entries(aliases)) {
+    if (!Object.hasOwn(info, locale)) {
+      throw new Error(`Alias "${alias}" points at unknown locale "${locale}"`);
+    }
+    aliasLookup.set(normalizeTag(alias), locale);
+  }
+  if (!Object.hasOwn(info, defaultLocale)) {
+    throw new Error(`Default locale "${defaultLocale}" is not in locales`);
+  }
+  const match = (tag) => {
+    if (!tag)
+      return null;
+    const full = normalizeTag(tag);
+    const language = full.split("-")[0] ?? "";
+    return lookup.get(full) ?? aliasLookup.get(full) ?? lookup.get(language) ?? aliasLookup.get(language) ?? null;
+  };
+  return {
+    locales,
+    defaultLocale,
+    tag: (locale) => info[locale].tag,
+    name: (locale) => info[locale].name,
+    match,
+    resolve: (...candidates) => {
+      for (const candidate of candidates) {
+        const locale = match(candidate);
+        if (locale)
+          return locale;
+      }
+      return defaultLocale;
+    }
+  };
+}
+function createLocaleSelector2(options) {
+  const { getLocale, setLocale, persist, onError } = options;
+  return async (next) => {
+    const previous = getLocale();
+    if (previous === next)
+      return;
+    await setLocale(next);
+    if (!persist)
+      return;
+    try {
+      await persist(next);
+    } catch (error) {
+      await setLocale(previous);
+      onError?.(error);
+    }
+  };
+}
+
+// src/i18n/index.ts
+var PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+function extractPlaceholders2(template) {
+  const names = template.matchAll(PLACEHOLDER_PATTERN).map((match) => match[1]);
+  return [...new Set(names)];
+}
+function interpolate2(template, ...args) {
+  const params = args[0] ?? {};
+  return template.replace(PLACEHOLDER_PATTERN, (match, name) => {
+    const value = Object.hasOwn(params, name) ? params[name] : undefined;
+    return value == null ? match : String(value);
+  });
+}
+function flattenMessages2(messages) {
+  const out = {};
+  const visit = (node, prefix) => {
+    for (const [key, value] of Object.entries(node)) {
+      if (typeof value === "string")
+        out[prefix + key] = value;
+      else
+        visit(value, `${prefix + key}.`);
+    }
+  };
+  visit(messages, "");
+  return out;
+}
+function createTranslator2(messages) {
+  const flat = flattenMessages2(messages);
+  return (key, ...args) => interpolate2(flat[key] ?? key, ...args);
+}
+function typedTranslate2(t) {
+  return t;
+}
+
+export { defineLocales2, createLocaleSelector2, extractPlaceholders2, interpolate2, flattenMessages2, createTranslator2, typedTranslate2 };