@xanots/sdk 0.0.2 → 0.0.3

package/dist/chunk-HQ2CBRVI.js

@@ -0,0 +1,530 @@
+import {
+  presetFilePath,
+  resolveAiPresets,
+  scaffoldProject
+} from "./chunk-CMZLPTGW.js";
+import {
+  runNpmCapturingStderr
+} from "./chunk-WUSKBXXD.js";
+import {
+  DEFAULT_FRAMEWORK,
+  allFrontendPresets,
+  findFrontendPreset,
+  initLanding,
+  renderApiTs,
+  renderCnUtil,
+  renderEnvExample,
+  renderGitignore,
+  renderIndexCss,
+  renderIndexHtml,
+  renderPackageJson,
+  renderReadme,
+  renderThemeModule,
+  renderTsconfig,
+  renderViteConfig,
+  renderXanoExampleMd,
+  renderXanoIndex,
+  resolveFrameworkFlag
+} from "./chunk-YZ4GU6F5.js";
+import {
+  DEFAULT_DARK_MODE,
+  curatedThemes,
+  defaultTheme,
+  defaultThemeChoice,
+  normalizeRadius,
+  resolveDarkModeFlag,
+  resolveFontFlag,
+  resolveIconsFlag,
+  resolveThemeFlag,
+  themeFromRegistryItem,
+  themeSwatch,
+  withRadius
+} from "./chunk-6DHJVLYP.js";
+import {
+  readVersion
+} from "./chunk-3NFUWXOC.js";
+import {
+  UsageError
+} from "./chunk-6USV65XA.js";
+import {
+  blank,
+  detail,
+  info,
+  step,
+  style,
+  success,
+  warn
+} from "./chunk-EZG76F7R.js";
+
+// src/emit/init-command.ts
+import { writeFileSync } from "fs";
+import { basename, join as join2, resolve } from "path";
+
+// src/emit/init-modules.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { pathToFileURL } from "url";
+function parseMarketplaceFlag(values) {
+  const packages = [];
+  for (const value of values) {
+    for (const raw of value.split(",")) {
+      const pkg = raw.trim();
+      if (pkg === "") continue;
+      if (pkg.startsWith("-")) {
+        throw new UsageError(
+          `\`--marketplace\`: "${pkg}" starts with a dash, so npm would read it as a flag, not a package.`,
+          { helpFor: { command: "init" } }
+        );
+      }
+      if (!packages.includes(pkg)) packages.push(pkg);
+    }
+  }
+  return packages;
+}
+function packageNameOf(specifier) {
+  const at = specifier.lastIndexOf("@");
+  return at > 0 ? specifier.slice(0, at) : specifier;
+}
+function readOptionRefs(raw) {
+  if (typeof raw !== "object" || raw === null) return {};
+  const refs = {};
+  for (const [name, value] of Object.entries(raw)) {
+    if (typeof value !== "object" || value === null) continue;
+    const entry = value;
+    const pkg = entry["package"];
+    const exported = entry["export"];
+    if (typeof pkg === "string" && pkg !== "" && typeof exported === "string" && exported !== "") {
+      refs[name] = { package: pkg, export: exported };
+    }
+  }
+  return refs;
+}
+function bindingNameFor(register) {
+  const bare = register.replace(/^register/, "");
+  return bare === "" ? "handle" : bare[0].toLowerCase() + bare.slice(1);
+}
+function readInstalledManifest(dir, pkg) {
+  const path = join(dir, "node_modules", ...pkg.split("/"), "package.json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function entryFileOf(dir, pkg, manifest) {
+  const root = join(dir, "node_modules", ...pkg.split("/"));
+  const exports = manifest["exports"];
+  const dot = typeof exports === "object" && exports !== null ? exports["."] : void 0;
+  const nested = typeof dot === "object" && dot !== null ? dot["import"] ?? dot["default"] : typeof dot === "string" ? dot : void 0;
+  const candidate = nested ?? manifest["module"] ?? manifest["main"];
+  if (typeof candidate !== "string") return null;
+  const file = join(root, candidate);
+  return existsSync(file) ? file : null;
+}
+async function readRegistration(dir, pkg) {
+  const manifest = readInstalledManifest(dir, pkg);
+  if (manifest === null) return { unwired: "it is not in node_modules after the install" };
+  const declared = manifest["xanots"];
+  if (typeof declared === "object" && declared !== null) {
+    const field = declared;
+    const register = field["register"];
+    if (typeof register === "string" && register !== "") {
+      return {
+        pkg,
+        register,
+        binding: field["returns"] === "handle" ? bindingNameFor(register) : null,
+        options: readOptionRefs(field["options"]),
+        source: "manifest"
+      };
+    }
+  }
+  const entry = entryFileOf(dir, pkg, manifest);
+  if (entry === null) return { unwired: "its package.json names no entry we could read" };
+  let names;
+  try {
+    const loaded = await import(pathToFileURL(entry).href);
+    names = Object.keys(loaded).filter(
+      (name) => /^register[A-Z]/.test(name) && typeof loaded[name] === "function"
+    );
+  } catch (error) {
+    return { unwired: `importing it failed (${error instanceof Error ? error.message : String(error)})` };
+  }
+  if (names.length === 0) {
+    return {
+      unwired: `it exports no register* function, and its package.json has no "xanots" field`
+    };
+  }
+  if (names.length > 1) {
+    return {
+      unwired: `it exports ${names.length} register* functions (${names.join(", ")}) \u2014 its package.json needs a "xanots" field naming the one to call`
+    };
+  }
+  return { pkg, register: names[0], binding: null, options: {}, source: "exports" };
+}
+function renderXanoIndexWithModules(appName, modules) {
+  const byPackage = /* @__PURE__ */ new Map();
+  const add = (pkg, name) => {
+    const names = byPackage.get(pkg) ?? /* @__PURE__ */ new Set();
+    names.add(name);
+    byPackage.set(pkg, names);
+  };
+  for (const m of modules) {
+    add(m.pkg, m.register);
+    for (const ref of Object.values(m.options)) add(ref.package, ref.export);
+  }
+  const imports = [...byPackage].map(([pkg, names]) => `import { ${[...names].sort().join(", ")} } from "${pkg}";`).join("\n");
+  const calls = modules.map((m) => {
+    const entries = Object.entries(m.options);
+    const opts = entries.length === 0 ? "" : `, { ${entries.map(([name, ref]) => `${name}: ${ref.export}`).join(", ")} }`;
+    const call = `${m.register}(app${opts});`;
+    return m.binding === null ? call : `const ${m.binding} = ${call}`;
+  }).join("\n");
+  const handles = modules.filter((m) => m.binding !== null);
+  const handleNote = handles.length === 0 ? "" : `
+ *
+ * ${handles.map((m) => `\`${m.binding}\` is ${m.pkg}'s handle \u2014 its endpoints and helpers.`).join("\n * ")}`;
+  return `import { workspace } from "@xanots/sdk";
+${imports}
+
+/**
+ * The ${appName} backend.
+ *
+ * A workspace is assembled by registering typed objects onto a workspace()
+ * instance and default-exporting it. The add-ons below were installed by
+ * \`xanots init --marketplace\` and registered for you.
+ *
+ * Each register* call mutates the workspace, so the order does not matter and
+ * the thing exported is the workspace itself. Add your own tables and endpoints
+ * beside them \u2014 xano/EXAMPLE.md walks through the first one.${handleNote}
+ */
+const app = workspace("${appName}");
+
+${calls}
+
+export default app;
+`;
+}
+function isPeerConflict(stderr) {
+  return /ERESOLVE|peer dep|peerinvalid/i.test(stderr);
+}
+async function installModules(dir, packages) {
+  const installed = [];
+  const failed = [];
+  const legacyPeer = [];
+  const registered = [];
+  const unwired = [];
+  for (const specifier of packages) {
+    step(`Adding ${specifier}`);
+    let result = runNpmCapturingStderr(["install", specifier], dir);
+    if (result.status !== 0 && isPeerConflict(result.stderr)) {
+      warn(
+        `${specifier} declares a peer range this CLI does not satisfy \u2014 retrying with --legacy-peer-deps.`
+      );
+      result = runNpmCapturingStderr(["install", specifier, "--legacy-peer-deps"], dir);
+      if (result.status === 0) legacyPeer.push(specifier);
+    }
+    if (result.status !== 0) {
+      failed.push(specifier);
+      warn(`npm install ${specifier} failed \u2014 the module was not added.`);
+      continue;
+    }
+    installed.push(specifier);
+    const pkg = packageNameOf(specifier);
+    const registration = await readRegistration(dir, pkg);
+    if ("unwired" in registration) unwired.push({ pkg, reason: registration.unwired });
+    else registered.push(registration);
+  }
+  const present = new Set(installed.map(packageNameOf));
+  const writable = [];
+  for (const registration of registered) {
+    const missing = Object.values(registration.options).map((ref) => ref.package).filter((pkg) => !present.has(pkg));
+    if (missing.length === 0) {
+      writable.push(registration);
+      continue;
+    }
+    unwired.push({
+      pkg: registration.pkg,
+      reason: `it needs ${[...new Set(missing)].join(", ")}, which this project does not have`
+    });
+  }
+  return { installed, failed, legacyPeer, registered: writable, unwired };
+}
+
+// src/emit/frontend-resolve.ts
+import { createInterface } from "readline/promises";
+function defaultFrontendPreset() {
+  const preset = findFrontendPreset(DEFAULT_FRAMEWORK);
+  if (preset === void 0) {
+    throw new Error(`Default frontend preset "${DEFAULT_FRAMEWORK}" is missing from the table.`);
+  }
+  return preset;
+}
+async function promptFramework() {
+  const presets = allFrontendPresets();
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(
+      `
+Which frontend framework?
+` + presets.map((p, i) => `  ${i + 1}) ${p.label}${p.id === DEFAULT_FRAMEWORK ? " (default)" : ""}`).join("\n") + `
+`
+    );
+    const answer = await rl.question(`Enter a number or name, or leave blank for the default: `);
+    const token = answer.trim().toLowerCase();
+    if (token === "") return defaultFrontendPreset();
+    const byIndex = Number.parseInt(token, 10);
+    if (Number.isInteger(byIndex) && byIndex >= 1 && byIndex <= presets.length) {
+      return presets[byIndex - 1];
+    }
+    return findFrontendPreset(token) ?? defaultFrontendPreset();
+  } finally {
+    rl.close();
+  }
+}
+async function resolveFrontendPreset(flag) {
+  if (flag !== void 0 && flag !== "") return resolveFrameworkFlag(flag);
+  if (process.stdin.isTTY && process.stderr.isTTY) return promptFramework();
+  return defaultFrontendPreset();
+}
+
+// src/emit/theme-resolve.ts
+import { createInterface as createInterface2 } from "readline/promises";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolvePath } from "path";
+function isRegistryRef(value) {
+  return /^https?:\/\//i.test(value) || value.toLowerCase().endsWith(".json");
+}
+async function loadRegistryTheme(ref) {
+  if (/^https?:\/\//i.test(ref)) {
+    let res;
+    try {
+      res = await fetch(ref, { headers: { accept: "application/json" } });
+    } catch (err) {
+      throw new Error(
+        `Could not fetch the theme at ${ref}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!res.ok) throw new Error(`Could not fetch the theme at ${ref}: ${res.status} ${res.statusText}`);
+    const text2 = await res.text();
+    return themeFromRegistryItem(parseJson(text2, ref), ref);
+  }
+  const path = resolvePath(ref);
+  let text;
+  try {
+    text = readFileSync2(path, "utf8");
+  } catch (err) {
+    throw new Error(
+      `Could not read the theme file ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return themeFromRegistryItem(parseJson(text, path), path);
+}
+function parseJson(text, source) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`${source} is not valid JSON \u2014 a registry theme is a JSON registry item.`);
+  }
+}
+async function themeFromFlag(raw) {
+  return isRegistryRef(raw.trim()) ? loadRegistryTheme(raw.trim()) : resolveThemeFlag(raw);
+}
+function swatch(theme, color) {
+  if (!color) return "";
+  const blocks = themeSwatch(theme).map(({ r, g, b }) => `\x1B[38;2;${r};${g};${b}m\u2588\x1B[0m`).join("");
+  return blocks === "" ? "" : `${blocks} `;
+}
+function colorEnabled() {
+  if (process.env.FORCE_COLOR) return process.env.FORCE_COLOR !== "0";
+  return !process.env.NO_COLOR && process.stderr.isTTY === true;
+}
+async function promptTheme() {
+  const themes = curatedThemes();
+  const color = colorEnabled();
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  try {
+    process.stderr.write(
+      `
+Which theme? (shadcn/ui color tokens \u2014 everything else is identical)
+` + themes.map((t, i) => `  ${i + 1}) ${swatch(t, color)}${t.label}${i === 0 ? " (default)" : ""}`).join("\n") + `
+${style.dim(
+        `  \u2026or any <base>-<accent> pair, or a registry theme URL. See \`xanots init --help\`.`
+      )}
+`
+    );
+    for (; ; ) {
+      const answer = (await rl.question(`Enter a number, a theme, or leave blank for the default: `)).trim();
+      if (answer === "") return defaultTheme();
+      const byIndex = Number.parseInt(answer, 10);
+      if (Number.isInteger(byIndex) && byIndex >= 1 && byIndex <= themes.length) {
+        return themes[byIndex - 1];
+      }
+      if (!isRegistryRef(answer)) {
+        try {
+          return resolveThemeFlag(answer);
+        } catch {
+          return defaultTheme();
+        }
+      }
+      try {
+        return await loadRegistryTheme(answer);
+      } catch (err) {
+        process.stderr.write(`${style.yellow("!")} ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function resolveThemeChoice(args) {
+  const dark = args.dark === void 0 || args.dark === "" ? DEFAULT_DARK_MODE : resolveDarkModeFlag(args.dark);
+  const fonts = {
+    ...args.font !== void 0 && args.font !== "" ? { sans: resolveFontFlag(args.font, "sans") } : {},
+    ...args.fontMono !== void 0 && args.fontMono !== "" ? { mono: resolveFontFlag(args.fontMono, "mono") } : {},
+    ...args.fontHeading !== void 0 && args.fontHeading !== "" ? { heading: resolveFontFlag(args.fontHeading, "heading") } : {}
+  };
+  const icons = args.icons === void 0 || args.icons === "" ? void 0 : resolveIconsFlag(args.icons).id;
+  let theme;
+  if (args.theme !== void 0 && args.theme !== "") {
+    theme = await themeFromFlag(args.theme);
+  } else if (process.stdin.isTTY && process.stderr.isTTY) {
+    theme = await promptTheme();
+  } else {
+    theme = defaultThemeChoice().theme;
+  }
+  if (args.radius !== void 0 && args.radius !== "") {
+    theme = withRadius(theme, normalizeRadius(args.radius));
+  }
+  return {
+    theme,
+    dark,
+    ...Object.keys(fonts).length === 0 ? {} : { fonts },
+    ...icons === void 0 ? {} : { icons }
+  };
+}
+
+// src/emit/init-command.ts
+function sanitizeAppName(raw) {
+  const name = raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return name === "" ? "app" : name;
+}
+function projectShellFiles(vars, preset, parts, choice = defaultThemeChoice()) {
+  return [
+    { path: "package.json", content: renderPackageJson(vars, preset, choice) },
+    { path: "tsconfig.json", content: renderTsconfig(preset) },
+    { path: "vite.config.ts", content: renderViteConfig(preset) },
+    { path: ".gitignore", content: renderGitignore(preset) },
+    { path: ".env.example", content: renderEnvExample() },
+    { path: "README.md", content: parts.readme },
+    // Skipped when the framework supplies its own entry document — see
+    // FrontendPreset.ownsHtmlEntry. A second index.html beside SvelteKit's
+    // app.html would never be served and would still read as the entry point.
+    ...preset.ownsHtmlEntry === true ? [] : [{ path: "frontend/index.html", content: renderIndexHtml(vars, preset, choice) }],
+    // Shared across every framework: both UI kits resolve against the same
+    // Tailwind v4 semantic tokens, back `cn()` with clsx + tailwind-merge, and
+    // look for library code at frontend/src/lib/. Only the alias NAME pointing
+    // at that directory differs, and the preset owns that.
+    { path: "frontend/src/index.css", content: renderIndexCss(choice) },
+    { path: "frontend/src/lib/api.ts", content: renderApiTs() },
+    { path: "frontend/src/lib/utils.ts", content: renderCnUtil(preset.libUtilsExtra) },
+    // The mode store behind `--dark toggle`, shared by both presets' toggles —
+    // it is plain DOM and localStorage, with nothing framework-shaped in it.
+    // `system` and `off` need no state, so nothing is written for them.
+    ...choice.dark === "toggle" ? [{ path: "frontend/src/lib/theme.ts", content: renderThemeModule() }] : [],
+    // The framework's own half: entry module, app component, vendored UI kit,
+    // and whatever tool config that kit's CLI reads.
+    ...preset.files(vars, parts.landing, choice)
+  ];
+}
+function buildFileSet(vars, preset, choice) {
+  return [
+    ...projectShellFiles(
+      vars,
+      preset,
+      { readme: renderReadme(vars, preset, choice), landing: initLanding(vars) },
+      choice
+    ),
+    { path: "xano/index.ts", content: renderXanoIndex(vars) },
+    { path: "xano/EXAMPLE.md", content: renderXanoExampleMd(vars) }
+  ];
+}
+async function runInitCommand(args) {
+  const targetArg = args.positionals[0] ?? ".";
+  const targetDir = resolve(targetArg);
+  const appName = sanitizeAppName(args.name ?? basename(targetDir));
+  const preset = await resolveFrontendPreset(args.framework);
+  const choice = await resolveThemeChoice(args);
+  const presets = await resolveAiPresets(args.ai);
+  const vars = { appName, sdkVersion: readVersion() };
+  step(
+    `Scaffolding ${style.bold(appName)} (${preset.label}, ${choice.theme.label}) in ${targetDir}`
+  );
+  const result = await scaffoldProject({
+    targetDir,
+    files: buildFileSet(vars, preset, choice),
+    presets,
+    appName,
+    force: args.force,
+    noInstall: args.noInstall,
+    // An `init` project's `xano/` is hand-authored, never machine-written: it is
+    // not refreshable, and `--force` must not clear it.
+    regenerable: false,
+    sdkVersion: readVersion(),
+    frontend: preset,
+    theme: choice
+  });
+  info(`Theme: ${choice.theme.label} \u2014 dark mode: ${choice.dark}`);
+  if (presets.length > 0) {
+    info(`AI instructions: ${presets.map(presetFilePath).join(", ")}`);
+  }
+  const modules = parseMarketplaceFlag(args.marketplace);
+  if (modules.length > 0) {
+    blank();
+    const outcome = await installModules(targetDir, modules);
+    if (outcome.registered.length > 0) {
+      writeFileSync(
+        join2(targetDir, "xano", "index.ts"),
+        renderXanoIndexWithModules(appName, outcome.registered),
+        "utf8"
+      );
+      info(
+        `Registered in xano/index.ts: ${outcome.registered.map((m) => m.pkg).join(", ")}`
+      );
+    }
+    for (const module of outcome.unwired) {
+      warn(`${module.pkg} is installed but not registered \u2014 ${module.reason}.`);
+      detail(`Import it in xano/index.ts and register it onto the workspace yourself.`);
+    }
+    if (outcome.legacyPeer.length > 0) {
+      warn(
+        `Installed with --legacy-peer-deps: ${outcome.legacyPeer.join(", ")}. npm refused the tree on peer ranges, so this one is not the tree npm would build on its own.`
+      );
+    }
+  }
+  blank();
+  success("Project ready.");
+  const cdHint = targetDir === process.cwd() ? "" : `  cd ${targetArg}
+`;
+  detail(
+    `Next steps:
+` + cdHint + (result.install === "installed" ? `` : `  npm install
+`) + `  npm run dev            # run the frontend
+  xanots login           # authenticate with Xano
+  npm run xano:deploy    # build the frontend, then deploy \u2192 live ephemeral URL
+
+The first export or deploy writes xano/xano.lock \u2014 commit it. It pins each
+object's identity, so renaming one later renames it instead of deleting and
+recreating it. See "xano.lock \u2014 commit it" in the README.`
+  );
+}
+
+export {
+  resolveFrontendPreset,
+  resolveThemeChoice,
+  sanitizeAppName,
+  projectShellFiles,
+  runInitCommand
+};
+//# sourceMappingURL=chunk-HQ2CBRVI.js.map

package/dist/{chunk-ZPEY5WE4.js → chunk-W2G2WPTB.js}

@@ -1,9 +1,9 @@
 import {
   compileBundle
-} from "./chunk-UVLVQWWF.js";
+} from "./chunk-3NFUWXOC.js";
 import {
   missingArgument
-} from "./chunk-IZW6MK3U.js";
+} from "./chunk-6USV65XA.js";
 
 // src/emit/bundle-input.ts
 import { existsSync, readFileSync } from "fs";
@@ -34,4 +34,4 @@ export {
   assertBundleInput,
   loadBundleText
 };
-//# sourceMappingURL=chunk-ZPEY5WE4.js.map
+//# sourceMappingURL=chunk-W2G2WPTB.js.map

package/dist/chunk-WUSKBXXD.js

@@ -0,0 +1,25 @@
+// src/emit/npm.ts
+import { spawnSync } from "child_process";
+function npmBinary() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function runNpm(args, cwd) {
+  const res = spawnSync(npmBinary(), [...args], { cwd, stdio: "inherit" });
+  return res.status ?? 1;
+}
+function runNpmCapturingStderr(args, cwd) {
+  const res = spawnSync(npmBinary(), [...args], {
+    cwd,
+    stdio: ["inherit", "inherit", "pipe"],
+    encoding: "utf8"
+  });
+  const stderr = res.stderr ?? "";
+  if (stderr !== "") process.stderr.write(stderr);
+  return { status: res.status ?? 1, stderr };
+}
+
+export {
+  runNpm,
+  runNpmCapturingStderr
+};
+//# sourceMappingURL=chunk-WUSKBXXD.js.map