one/dist/esm/cli.js

One is a new React Framework that makes Vite serve both native and web.

import { defineCommand, runMain, showUsage } from "citty";
import { readFileSync } from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";
import colors from "picocolors";
function getPackageVersion() {
  let dirname;
  typeof __dirname < "u" ? dirname = __dirname : dirname = path.dirname(fileURLToPath(import.meta.url));
  const packagePath = path.join(dirname, "..", "..", "package.json");
  return JSON.parse(readFileSync(packagePath, "utf-8")).version;
}
const version = getPackageVersion(), DOCS_BASE = "https://onestack.dev/docs", docsLinks = {
  dev: `${DOCS_BASE}/one-dev`,
  build: `${DOCS_BASE}/one-build`,
  serve: `${DOCS_BASE}/one-serve`,
  prebuild: `${DOCS_BASE}/guides-ios-native`,
  "run:ios": `${DOCS_BASE}/guides-ios-native`,
  "run:android": `${DOCS_BASE}/guides-ios-native`,
  clean: `${DOCS_BASE}/configuration`,
  patch: `${DOCS_BASE}/configuration`,
  "generate-routes": `${DOCS_BASE}/routing-typed-routes`,
  typegen: `${DOCS_BASE}/routing-typed-routes`
};
function withDocsLink(description, command) {
  return `${description}

Docs: ${docsLinks[command]}`;
}
path.sep !== "/" && console.warn(
  colors.bgYellow("WARNING: UNSUPPORTED OS") + colors.yellow(
    " - It appears you\u2019re using Windows, which is currently not supported. You may experience unexpected issues."
  )
);
const modes = {
  development: "development",
  production: "production"
};
function lastValue(arg) {
  return Array.isArray(arg) ? arg[arg.length - 1] : arg;
}
const dev = defineCommand({
  meta: {
    name: "dev",
    version,
    description: withDocsLink("Start the dev server", "dev")
  },
  args: {
    clean: {
      type: "boolean"
    },
    host: {
      type: "string"
    },
    port: {
      type: "string"
    },
    https: {
      type: "boolean"
    },
    mode: {
      type: "string",
      description: 'If set to "production" you can run the development server but serve the production bundle'
    },
    "debug-bundle": {
      type: "string",
      description: "Will output the bundle to a temp file and then serve it from there afterwards allowing you to easily edit the bundle to debug problems."
    },
    debug: {
      type: "string",
      description: "Pass debug args to Vite"
    }
  },
  async run({ args }) {
    const { dev: dev2 } = await import("./cli/dev");
    await dev2({
      ...args,
      port: lastValue(args.port),
      host: lastValue(args.host),
      debugBundle: lastValue(args["debug-bundle"]),
      mode: modes[lastValue(args.mode)]
    });
  }
}), buildCommand = defineCommand({
  meta: {
    name: "build",
    version,
    description: withDocsLink("Build your app", "build")
  },
  args: {
    step: {
      type: "string",
      required: !1
    },
    // limit the pages built
    only: {
      type: "string",
      required: !1
    },
    platform: {
      type: "string",
      description: "One of: web, ios, android",
      default: "web",
      required: !1
    },
    "skip-env": {
      type: "boolean",
      description: "Skip loading .env files during build",
      required: !1
    }
  },
  async run({ args }) {
    const { build } = await import("./cli/build"), platforms = {
      ios: "ios",
      web: "web",
      android: "android"
    };
    if (args.platform && !platforms[args.platform])
      throw new Error(`Invalid platform: ${args.platform}`);
    const platform = platforms[args.platform] || "web";
    await build({
      only: args.only,
      platform,
      step: args.step,
      skipEnv: args["skip-env"]
    }), process.exit(0);
  }
}), serveCommand = defineCommand({
  meta: {
    name: "serve",
    version,
    description: withDocsLink("Serve a built app for production", "serve")
  },
  args: {
    host: {
      type: "string"
    },
    port: {
      type: "string"
    },
    compress: {
      type: "boolean"
    },
    loadEnv: {
      type: "boolean"
    }
  },
  async run({ args }) {
    const { serve } = await import("./serve"), port = lastValue(args.port), host = lastValue(args.host);
    await serve({
      port: port ? +port : void 0,
      host,
      compress: args.compress,
      loadEnv: !!args.loadEnv
    });
  }
}), prebuild = defineCommand({
  meta: {
    name: "prebuild",
    version,
    description: withDocsLink("Prebuild native project", "prebuild")
  },
  args: {
    platform: {
      type: "string",
      description: "ios or android"
    },
    expo: {
      type: "boolean",
      description: "expo or non-expo folders",
      default: !0
    },
    "no-install": {
      type: "boolean",
      description: "skip installing native dependencies",
      default: !1
    }
  },
  async run({ args }) {
    args.install === !1 && (args["no-install"] = !0);
    const { run } = await import("./cli/prebuild");
    await run(args);
  }
}), runIos = defineCommand({
  meta: {
    name: "run:ios",
    version,
    description: withDocsLink("Run the iOS app", "run:ios")
  },
  args: {},
  async run({ args }) {
    const { run } = await import("./cli/runIos");
    await run(args);
  }
}), runAndroid = defineCommand({
  meta: {
    name: "run:android",
    version,
    description: withDocsLink("Run the Android app", "run:android")
  },
  args: {},
  async run({ args }) {
    const { run } = await import("./cli/runAndroid");
    await run(args);
  }
}), clean = defineCommand({
  meta: {
    name: "clean",
    version: "0.0.0",
    description: withDocsLink("Clean build folders", "clean")
  },
  args: {},
  async run() {
    const { clean: vxrnClean } = await import("vxrn");
    await vxrnClean({
      root: process.cwd()
    });
  }
}), patch = defineCommand({
  meta: {
    name: "patch",
    version: "0.0.0",
    description: withDocsLink("Apply package patches", "patch")
  },
  args: {
    force: {
      type: "boolean",
      description: "Force re-apply all patches"
    }
  },
  async run({ args }) {
    const { run } = await import("./cli/patch");
    await run(args);
  }
}), generateRoutes = defineCommand({
  meta: {
    name: "generate-routes",
    version,
    description: withDocsLink(
      "Generate route type definitions (routes.d.ts)",
      "generate-routes"
    )
  },
  args: {
    appDir: {
      type: "string",
      description: 'Path to app directory (default: "app")'
    },
    typed: {
      type: "string",
      description: 'Auto-generate route helpers. Options: "type" (type-only helpers) or "runtime" (runtime helpers)'
    }
  },
  async run({ args }) {
    const { run } = await import("./cli/generateRoutes");
    await run(args);
  }
}), typegen = defineCommand({
  meta: {
    name: "typegen",
    version,
    description: withDocsLink(
      "Generate routes.d.ts (alias for generate-routes)",
      "typegen"
    )
  },
  args: {
    appDir: {
      type: "string",
      description: 'Path to app directory (default: "app")'
    },
    typed: {
      type: "string",
      description: 'Auto-generate route helpers. Options: "type" (type-only helpers) or "runtime" (runtime helpers)'
    }
  },
  async run({ args }) {
    const { run } = await import("./cli/generateRoutes");
    await run(args);
  }
}), daemonCommand = defineCommand({
  meta: {
    name: "daemon",
    version,
    description: "Multi-app development server proxy"
  },
  args: {
    subcommand: {
      type: "positional",
      description: "Subcommand: start, stop, status, route (default: start)",
      required: !1
    },
    port: {
      type: "string",
      description: "Port to listen on (default: 8081)"
    },
    host: {
      type: "string",
      description: "Host to bind to (default: 0.0.0.0)"
    },
    app: {
      type: "string",
      description: "Bundle ID for route command"
    },
    slot: {
      type: "string",
      description: "Slot number for route command"
    },
    project: {
      type: "string",
      description: "Project path for route command"
    },
    tui: {
      type: "boolean",
      description: "Show TUI (default: true if TTY)"
    }
  },
  async run({ args }) {
    const { daemon } = await import("./cli/daemon");
    await daemon({
      ...args,
      port: lastValue(args.port),
      host: lastValue(args.host)
    });
  }
}), subCommands = {
  dev,
  clean,
  build: buildCommand,
  prebuild,
  "run:ios": runIos,
  "run:android": runAndroid,
  patch,
  serve: serveCommand,
  "generate-routes": generateRoutes,
  typegen,
  daemon: daemonCommand
}, subMain = defineCommand({
  meta: {
    name: "main",
    version,
    description: "Welcome to One"
  },
  subCommands
}), main = defineCommand({
  meta: {
    name: "main",
    version,
    description: "Welcome to One"
  },
  args: {
    name: {
      type: "positional",
      description: "Folder name to place the app into",
      required: !1
    }
  },
  async run({ args }) {
    if (subCommands[args.name]) {
      runMain(subMain);
      return;
    }
    const { cliMain } = await import("./cli/main");
    await cliMain(args);
  }
}), helpIndex = process.argv.indexOf("--help");
if (helpIndex > 0) {
  const subCommandName = process.argv[helpIndex - 1], subCommand = subCommands[subCommandName];
  subCommand ? showUsage(subCommand) : showUsage(subMain);
} else
  runMain(main);
//# sourceMappingURL=cli.js.map