one/dist/cjs/cli.js

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

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
  mod
));
var import_node_fs = require("node:fs"), import_node_path = __toESM(require("node:path"), 1), import_node_url = require("node:url"), import_citty = require("citty"), import_picocolors = __toESM(require("picocolors"), 1);
const import_meta = {};
function getPackageVersion() {
  let dirname;
  typeof __dirname < "u" ? dirname = __dirname : dirname = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
  const packagePath = import_node_path.default.join(dirname, "..", "..", "package.json");
  return JSON.parse((0, import_node_fs.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`
};
function withDocsLink(description, command) {
  return `${description}

Docs: ${docsLinks[command]}`;
}
import_node_path.default.sep !== "/" && console.warn(
  import_picocolors.default.bgYellow("WARNING: UNSUPPORTED OS") + import_picocolors.default.yellow(
    " - It appears you\u2019re using Windows, which is currently not supported. You may experience unexpected issues."
  )
);
const modes = {
  development: "development",
  production: "production"
}, dev = (0, import_citty.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,
      debugBundle: args["debug-bundle"],
      mode: modes[args.mode]
    });
  }
}), buildCommand = (0, import_citty.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
    }
  },
  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
    }), process.exit(0);
  }
}), serveCommand = (0, import_citty.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");
    await serve({
      port: args.port ? +args.port : void 0,
      host: args.host,
      compress: args.compress,
      loadEnv: !!args.loadEnv
    });
  }
}), prebuild = (0, import_citty.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 = (0, import_citty.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 = (0, import_citty.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 = (0, import_citty.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 = (0, import_citty.defineCommand)({
  meta: {
    name: "patch",
    version: "0.0.0",
    description: withDocsLink("Apply package patches", "patch")
  },
  args: {},
  async run({ args }) {
    const { run } = await import("./cli/patch");
    await run(args);
  }
}), generateRoutes = (0, import_citty.defineCommand)({
  meta: {
    name: "generate-routes",
    version,
    description: withDocsLink("Generate route type definitions", "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);
  }
}), subCommands = {
  dev,
  clean,
  build: buildCommand,
  prebuild,
  "run:ios": runIos,
  "run:android": runAndroid,
  patch,
  serve: serveCommand,
  "generate-routes": generateRoutes
}, subMain = (0, import_citty.defineCommand)({
  meta: {
    name: "main",
    version,
    description: "Welcome to One"
  },
  subCommands
}), main = (0, import_citty.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]) {
      (0, import_citty.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 && (0, import_citty.showUsage)(subCommand);
} else
  (0, import_citty.runMain)(main);
//# sourceMappingURL=cli.js.map