@winjs-dev/create-win 1.0.0-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 winjs-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+# @winjs-dev/create-win
+
+<p align="center">
+  <img src="https://img.shields.io/npm/v/@winjs-dev/create-win.svg" alt="npm version" />
+  <img src="https://img.shields.io/npm/dm/@winjs-dev/create-win.svg" alt="npm downloads" />
+  <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="license" />
+</p>
+
+> 🚀 WinJS 框架官方脚手架工具，快速创建现代化前端应用项目
+
+## 📋 项目简介
+
+`@winjs-dev/create-win` 是 WinJS 框架的官方脚手架工具，提供了丰富的项目模板和配置选项。通过交互式命令行界面，帮助开发者快速搭建基于 WinJS 框架的各类前端应用项目，包括 H5 应用、企业级 Web 应用、混合式移动应用等。
+
+## ✨ 核心特性
+
+- 🎯 **多种项目模板** - 提供 4 种预设模板，覆盖不同应用场景
+- 🛠️ **交互式配置** - 基于 clack-prompts 的友好命令行交互体验
+- 📦 **多包管理器支持** - 支持 npm、yarn、pnpm、bun 等包管理器
+- 🔧 **开箱即用** - 集成完整的开发工具链和最佳实践配置
+- 🌐 **现代化技术栈** - 基于 Vue 3、TypeScript、现代构建工具
+- 📱 **移动端优化** - 内置移动端适配和调试工具
+- 🎨 **代码规范** - 预配置 ESLint、Prettier、StyleLint 等代码质量工具
+- ⚡ **快速开发** - 支持热更新、Mock 数据、代理等开发特性
+
+## 🚀 快速开始
+
+### 安装
+
+```bash
+# 使用 npm
+npm create @winjs-dev/win@latest my-project
+
+# 使用 yarn
+yarn create @winjs-dev/win my-project
+
+# 使用 pnpm
+pnpm create @winjs-dev/win my-project
+
+# 使用 bun
+bun create @winjs-dev/win my-project
+```
+
+### 或者全局安装
+
+```bash
+# 全局安装
+npm install -g @winjs-dev/create-win
+
+# 创建项目
+create-win my-project
+```
+
+### 使用方式
+
+```bash
+# 交互式创建项目
+create-win
+
+# 指定项目名称
+create-win my-project
+
+# 查看版本
+create-win --version
+
+# 查看帮助
+create-win --help
+```
+
+## 📚 项目模板
+
+### 🌐 App 模板
+**适用场景：** 移动端 H5 应用开发
+
+**技术栈：**
+- Vue 3.2+ + Vue Router 4.x
+- TypeScript 5.0+
+- WinJS 构建工具链
+- Less + PostCSS
+- 移动端适配解决方案
+
+**特性：**
+- 📱 移动端优化（REM 适配、VConsole 调试）
+- 🔧 插件化架构（请求拦截、移动端调试等）
+- 🎨 完整样式解决方案
+
+### 💻 PC 模板
+**适用场景：** PC 端 Web 应用
+
+**技术栈：**
+- Vue 3.2.x + Vue Router 4.x
+- TypeScript 5.x
+- WinJS 构建工具链
+- Less + PostCSS
+
+**特性：**
+- 🎯 PC 端优化体验
+- 📦 模块联邦支持
+
+### 🎯 Sample 模板
+**适用场景：** 学习示例和快速原型
+
+**技术栈：**
+- Vue 3.x 基础配置
+- TypeScript
+- 最小化依赖
+
+**特性：**
+- 📚 学习友好的代码结构
+- 🚀 最小化配置
+- 💡 最佳实践示例
+
+### 🔌 Plugin 模板
+**适用场景：** WinJS 插件开发
+
+**技术栈：**
+- TypeScript
+- WinJS 插件 API
+- 测试工具链
+
+**特性：**
+- 🔌 插件开发框架
+- 🧪 完整测试配置
+- 📖 插件文档模板
+
+## 🛠️ 配置选项
+
+创建项目时，脚手架会询问以下配置选项：
+
+- **项目名称** - 项目目录名和包名
+- **项目模板** - 选择适合的项目模板
+- **包管理器** - npm、yarn、pnpm、bun
+- **Git 初始化** - 是否初始化 Git 仓库
+- **依赖安装** - 是否自动安装依赖
+- **代码规范** - 是否启用 Husky Git hooks
+- **作者信息** - 项目作者和邮箱
+
+## 📁 生成的项目结构
+
+```
+my-project/
+├── src/                    # 源代码目录
+│   ├── app.js             # 应用入口文件
+│   ├── global.less        # 全局样式
+│   ├── constant.js        # 常量定义
+│   ├── assets/            # 静态资源
+│   ├── layouts/           # 布局组件
+│   ├── pages/             # 页面组件
+│   └── services/          # 服务层
+├── .winrc.ts              # WinJS 配置文件
+├── package.json           # 项目依赖配置
+├── tsconfig.json          # TypeScript 配置
+├── .eslintrc.js           # ESLint 配置
+├── .prettierrc.js         # Prettier 配置
+├── .stylelintrc.js        # StyleLint 配置
+├── .gitignore             # Git 忽略文件
+└── README.md              # 项目说明文档
+```
+
+## 🔧 开发工具链
+
+所有模板都内置了完整的开发工具链：
+
+### 代码质量
+- **ESLint** - JavaScript/TypeScript 代码检查
+- **Prettier** - 代码格式化工具
+- **StyleLint** - CSS/Less 样式检查
+- **F2ELint** - 前端代码规范工具
+
+### Git 工作流
+- **Husky** - Git hooks 管理
+- **lint-staged** - 暂存文件检查
+- **commitlint** - 提交信息规范检查
+
+### 构建工具
+- **WinJS** - 现代化开发元框架
+- **Webpack/Vite/Rsbuild** - 多种构建工具支持
+- **Babel** - JavaScript 编译器
+- **PostCSS** - CSS 后处理器
+
+## 📖 环境要求
+
+- **Node.js** >= 18.0.0
+- **npm** >= 8.0.0 或其他包管理器的对应版本
+
+## 🔗 相关链接
+
+- [WinJS 官方文档](https://winjs-dev.github.io/winjs-docs)
+- [问题反馈](https://github.com/winjs-dev/winjs/issues)
+
+---
+
+<p align="center">
+  如果这个项目对你有帮助，请给我们一个 ⭐！
+</p>

package/bin/create-win.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+process.env.WIN_LOGGER = 'none';
+require('../dist/cli');

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,23 @@
+// src/cli.ts
+var import_utils = require("@winner-fed/utils");
+var args = (0, import_utils.yParser)(process.argv.slice(2), {
+  alias: {
+    version: ["v"],
+    help: ["h"]
+  },
+  boolean: ["version"]
+});
+if (args.version && !args._[0]) {
+  args._[0] = "version";
+  const local = (0, import_utils.isLocalDev)() ? import_utils.chalk.cyan("@local") : "";
+  const { name, version } = require("../package.json");
+  console.log(`${name}@${version}${local}`);
+} else {
+  require("./").default({
+    cwd: process.cwd(),
+    args
+  }).catch((err) => {
+    console.error(`Create failed, ${err.message}`);
+    console.error(err);
+  });
+}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { yParser } from '@winner-fed/utils';
+import { type WinTemplate } from './template';
+interface ITemplateArgs {
+    template?: WinTemplate;
+}
+interface IArgs extends yParser.Arguments, ITemplateArgs {
+    default?: boolean;
+    git?: boolean;
+    install?: boolean;
+}
+interface ITemplatePluginParams {
+    pluginName?: string;
+}
+interface ITemplateParams extends ITemplatePluginParams {
+    version: string;
+    projectName: string;
+    appContainerName: string;
+    npmClient: ENpmClient | string;
+    registry: string;
+    author: string;
+    email: string;
+    withHusky: boolean;
+    extraNpmrc: string;
+}
+declare enum ENpmClient {
+    npm = "npm",
+    yarn = "yarn",
+    pnpm = "pnpm"
+}
+declare enum ETemplate {
+    app = "app",
+    pc = "pc",
+    plugin = "plugin",
+    sample = "sample"
+}
+export interface IDefaultData extends ITemplateParams {
+    appTemplate?: ETemplate;
+}
+interface IGeneratorOpts {
+    cwd: string;
+    args: IArgs;
+    defaultData?: IDefaultData;
+}
+declare const _default: ({ cwd, args, defaultData, }: IGeneratorOpts) => Promise<void>;
+export default _default;

package/dist/index.js

@@ -0,0 +1,396 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var clackPrompts = __toESM(require("@winner-fed/clack-prompts"));
+var import_utils = require("@winner-fed/utils");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_template = require("./template");
+var devCommands = {
+  pnpm: "pnpm dev",
+  yarn: "yarn dev",
+  npm: "npm run dev",
+  bun: "bun run dev"
+};
+function parseStr(str) {
+  return str.replace(/-(\w)/g, function(_$0, $1) {
+    return $1.toUpperCase();
+  });
+}
+function getUUID() {
+  return Number(Math.random().toString().substr(2)).toString(36);
+}
+function generateOnlyContainer(str) {
+  return `${parseStr(str)}${getUUID()}`;
+}
+var pkg = require("../package");
+var DEFAULT_DATA = {
+  pluginName: "winjs-plugin-demo",
+  projectName: "winjs-template",
+  email: "i@domain.com",
+  author: "winjs",
+  appContainerName: "root",
+  version: pkg.version,
+  npmClient: "pnpm" /* pnpm */,
+  registry: import_template.ERegistry.npm,
+  withHusky: false,
+  extraNpmrc: "",
+  appTemplate: "app" /* app */
+};
+var src_default = async ({
+  cwd,
+  args,
+  defaultData = DEFAULT_DATA
+}) => {
+  let [name] = args._;
+  let npmClient = "pnpm" /* pnpm */;
+  let registry = import_template.ERegistry.npm;
+  let appTemplate = (defaultData == null ? void 0 : defaultData.appTemplate) || "app" /* app */;
+  const { username, email } = await (0, import_utils.getGitInfo)();
+  const author = email && username ? `${username} <${email}>` : "";
+  let pluginName = `winjs-plugin-${name || "demo"}`;
+  let projectName = `winjs-template-${name || "demo"}`;
+  const appContainerName = generateOnlyContainer(projectName);
+  let target = name ? (0, import_path.join)(cwd, name) : cwd;
+  const { isCancel, text, select, intro, outro, box, taskLog } = clackPrompts;
+  const exitPrompt = () => {
+    outro(import_utils.chalk.red("Exit create-win"));
+    process.exit(1);
+  };
+  const setName = async () => {
+    name = await text({
+      message: "What's the target folder name?",
+      initialValue: name || "my-app",
+      validate: (value) => {
+        if (!value.length) {
+          return "Please input project name";
+        }
+        if (value != "." && import_utils.fsExtra.existsSync((0, import_path.join)(cwd, value))) {
+          return `Folder ${value} already exists`;
+        }
+      }
+    });
+  };
+  const selectAppTemplate = async () => {
+    appTemplate = await select({
+      message: "Pick WinJS App Template",
+      options: [
+        { label: "Simple App", value: "sample" /* sample */ },
+        {
+          label: "PC Web",
+          value: "pc" /* pc */,
+          hint: "for pc web"
+        },
+        { label: "H5 App", value: "app" /* app */ },
+        {
+          label: "WinJS Plugin",
+          value: "plugin" /* plugin */,
+          hint: "for plugin development"
+        }
+      ],
+      initialValue: "sample" /* sample */
+    });
+  };
+  const selectNpmClient = async () => {
+    npmClient = await select({
+      message: "Pick Npm Client",
+      options: [
+        { label: "npm" /* npm */, value: "npm" /* npm */ },
+        { label: "yarn" /* yarn */, value: "yarn" /* yarn */, hint: "recommended" },
+        { label: "pnpm" /* pnpm */, value: "pnpm" /* pnpm */ }
+      ],
+      initialValue: "yarn" /* yarn */
+    });
+  };
+  const selectRegistry = async () => {
+    registry = await select({
+      message: "Pick Npm Registry",
+      options: [
+        {
+          label: "npm",
+          value: import_template.ERegistry.npm
+        },
+        {
+          label: "taobao",
+          value: import_template.ERegistry.taobao,
+          hint: "recommended for China"
+        }
+      ],
+      initialValue: import_template.ERegistry.taobao
+    });
+  };
+  const internalTemplatePrompts = async () => {
+    intro("Creating a new WinJS project...");
+    await setName();
+    if (isCancel(name)) {
+      exitPrompt();
+    }
+    target = (0, import_path.join)(cwd, name);
+    await selectAppTemplate();
+    if (isCancel(appTemplate)) {
+      exitPrompt();
+    }
+    await selectNpmClient();
+    if (isCancel(npmClient)) {
+      exitPrompt();
+    }
+    await selectRegistry();
+    if (isCancel(registry)) {
+      exitPrompt();
+    }
+    const isPlugin = appTemplate === "plugin" /* plugin */;
+    if (isPlugin) {
+      pluginName = await text({
+        message: `What's the plugin name?`,
+        placeholder: pluginName,
+        validate: (value) => {
+          if (!(value == null ? void 0 : value.length)) {
+            return "Please input plugin name";
+          }
+        }
+      });
+      if (isCancel(pluginName)) {
+        exitPrompt();
+      }
+    }
+  };
+  const useDefaultData = !!args.default;
+  const useExternalTemplate = !!args.template;
+  switch (true) {
+    case useExternalTemplate:
+      await selectNpmClient();
+      if (isCancel(npmClient)) {
+        exitPrompt();
+      }
+      await selectRegistry();
+      if (isCancel(registry)) {
+        exitPrompt();
+      }
+      await (0, import_template.unpackTemplate)({
+        template: args.template,
+        dest: target,
+        registry
+      });
+      break;
+    default:
+      if (!useDefaultData) {
+        await internalTemplatePrompts();
+      }
+  }
+  const version = pkg.version;
+  const monorepoRoot = await detectMonorepoRoot({ target });
+  const inMonorepo = !!monorepoRoot;
+  const projectRoot = inMonorepo ? monorepoRoot : target;
+  const shouldInitGit = args.git !== false;
+  const withHusky = shouldInitGit && !inMonorepo;
+  let pnpmExtraNpmrc = "";
+  const isPnpm = npmClient === "pnpm" /* pnpm */;
+  let pnpmMajorVersion;
+  if (isPnpm) {
+    pnpmMajorVersion = await getPnpmMajorVersion();
+    if (pnpmMajorVersion === 7) {
+      pnpmExtraNpmrc = `strict-peer-dependencies=false`;
+    }
+  }
+  const injectInternalTemplateFiles = async () => {
+    const generator = new import_utils.BaseGenerator({
+      path: (0, import_path.join)(__dirname, "..", "templates", appTemplate),
+      target,
+      slient: true,
+      data: useDefaultData ? defaultData : {
+        version: version.includes("-canary.") ? version : `^${version}`,
+        npmClient,
+        registry,
+        author,
+        email,
+        withHusky,
+        extraNpmrc: isPnpm ? pnpmExtraNpmrc : "",
+        pluginName,
+        projectName,
+        appContainerName
+      }
+    });
+    await generator.run();
+  };
+  if (!useExternalTemplate) {
+    await injectInternalTemplateFiles();
+  }
+  const context = {
+    inMonorepo,
+    target,
+    projectRoot
+  };
+  if (!withHusky) {
+    await removeHusky(context);
+  }
+  if (inMonorepo) {
+    await moveNpmrc(context);
+  }
+  if (shouldInitGit) {
+    await initGit(context);
+  } else {
+    import_utils.logger.info(`Skip Git init`);
+  }
+  const isPnpm8 = pnpmMajorVersion === 8;
+  if (!useDefaultData && args.install !== false) {
+    const installTask = taskLog(`Installing dependencies with ${npmClient}...`);
+    if (isPnpm8) {
+      await installWithPnpm8(target);
+    } else {
+      const isYarn = npmClient === "yarn" /* yarn */;
+      try {
+        await execute(npmClient, [isYarn ? "" : "install"], {
+          cwd: target,
+          onData: (data) => {
+            installTask.text = data;
+          }
+        });
+      } catch (error) {
+        installTask.fail(`Failed to install dependencies with ${npmClient}`);
+        throw error;
+      }
+    }
+    installTask.success(`Installed dependencies with ${npmClient}`);
+  } else {
+    import_utils.logger.info(`Skip install deps`);
+    if (isPnpm8) {
+      import_utils.logger.warn(
+        import_utils.chalk.yellow(
+          `You current using pnpm v8, it will install minimal version of dependencies`
+        )
+      );
+      import_utils.logger.warn(
+        import_utils.chalk.green(
+          `Recommended that you run ${import_utils.chalk.bold.cyan(
+            "pnpm up -L"
+          )} to install latest version of dependencies`
+        )
+      );
+    }
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(target, ".husky/pre-commit"))) {
+    if (process.platform !== "win32") {
+      import_utils.execa.execaCommandSync(`chmod +x ${(0, import_path.join)(target, ".husky/pre-commit")}`);
+      import_utils.logger.info(`Chmod ${(0, import_path.join)(target, ".husky/pre-commit")} successful`);
+    }
+  }
+  if ((0, import_fs.existsSync)((0, import_path.join)(target, ".husky/commit-msg"))) {
+    if (process.platform !== "win32") {
+      import_utils.execa.execaCommandSync(`chmod +x ${(0, import_path.join)(target, ".husky/commit-msg")}`);
+      import_utils.logger.info(`Chmod ${(0, import_path.join)(target, ".husky/commit-msg")} successful`);
+    }
+  }
+  box(
+    `
+1: ${import_utils.chalk.bold(import_utils.chalk.cyan(`cd ${target}`))}
+2: ${import_utils.chalk.bold(import_utils.chalk.cyan(devCommands[npmClient]))}
+
+To close the dev server, hit ${import_utils.chalk.bold(import_utils.chalk.cyan("Ctrl+C"))}
+    `.trim(),
+    "Next Steps"
+  );
+  outro(import_utils.chalk.green(`Create success!`));
+};
+async function detectMonorepoRoot(opts) {
+  const { target } = opts;
+  const rootPkg = await import_utils.pkgUp.pkgUp({ cwd: (0, import_path.dirname)(target) });
+  if (!rootPkg) {
+    return null;
+  }
+  const rootDir = (0, import_path.dirname)(rootPkg);
+  if ((0, import_utils.tryPaths)([
+    (0, import_path.join)(rootDir, "lerna.json"),
+    (0, import_path.join)(rootDir, "pnpm-workspace.yaml")
+  ])) {
+    return rootDir;
+  }
+  return null;
+}
+async function moveNpmrc(opts) {
+  const { target, projectRoot } = opts;
+  const sourceNpmrc = (0, import_path.join)(target, "./.npmrc");
+  const targetNpmrc = (0, import_path.join)(projectRoot, "./.npmrc");
+  if (!(0, import_fs.existsSync)(targetNpmrc)) {
+    await import_utils.fsExtra.copyFile(sourceNpmrc, targetNpmrc);
+  }
+  await import_utils.fsExtra.remove(sourceNpmrc);
+}
+async function initGit(opts) {
+  const { projectRoot } = opts;
+  const isGit = (0, import_fs.existsSync)((0, import_path.join)(projectRoot, ".git"));
+  if (isGit) return;
+  try {
+    await import_utils.execa.execa("git", ["init"], { cwd: projectRoot });
+  } catch {
+    import_utils.logger.error(`Initial the git repo failed`);
+  }
+}
+async function removeHusky(opts) {
+  const dir = (0, import_path.join)(opts.target, "./.husky");
+  if ((0, import_fs.existsSync)(dir)) {
+    await import_utils.fsExtra.remove(dir);
+  }
+}
+async function installWithPnpm8(cwd) {
+  await import_utils.execa.execa("pnpm", ["up", "-L"], { cwd, stdio: "inherit" });
+}
+async function getPnpmMajorVersion() {
+  try {
+    const { stdout } = await import_utils.execa.execa("pnpm", ["--version"]);
+    return parseInt(stdout.trim().split(".")[0], 10);
+  } catch (e) {
+    throw new Error("Please install pnpm first", { cause: e });
+  }
+}
+async function execute(cmd, args, options) {
+  const child = import_utils.execa.execa(cmd, args, {
+    stdio: "pipe",
+    cwd: options.cwd
+  });
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    (_a = child.stdout) == null ? void 0 : _a.on("data", (data) => {
+      options.onData(data);
+    });
+    (_b = child.stderr) == null ? void 0 : _b.on("data", (data) => {
+      options.onData(data);
+    });
+    child.on("close", (code) => {
+      resolve(code);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}

package/dist/template.d.ts

@@ -0,0 +1,13 @@
+export declare enum ERegistry {
+    npm = "https://registry.npmjs.com/",
+    taobao = "https://registry.npmmirror.com/",
+    winner = "http://artifactory.hundsun.com/artifactory/api/npm/winnerproject-npm-virtual/"
+}
+export type WinTemplate = `@winner-fed/${string}-template`;
+interface IUnpackTemplateOpts {
+    template: WinTemplate;
+    dest: string;
+    registry: ERegistry | string;
+}
+export declare const unpackTemplate: (opts: IUnpackTemplateOpts) => Promise<string>;
+export {};