@duonghieu0712z/create-tauri-vue-template 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 duonghieu0712z
+
+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,74 @@
+# Create Tauri Vue Template
+
+Create a Tauri 2 + Vue 3 desktop app from the `tauri-vue-template` starter.
+
+## Usage
+
+Run the interactive scaffold:
+
+```bash
+pnpm create @duonghieu0712z/tauri-vue-template@latest
+```
+
+Pass values directly when needed:
+
+```bash
+pnpm create @duonghieu0712z/tauri-vue-template@latest my-app --name "My App" --id "com.example.my-app" --author "Your Name"
+```
+
+The CLI copies the bundled template into the target directory, updates the package name, Tauri product name, application identifier, Rust crate names, release workflow metadata, and VS Code workspace settings.
+
+## Development
+
+Install dependencies:
+
+```bash
+pnpm install
+```
+
+The CLI source lives in `src/` and is compiled to `dist/`. The published package runs the compiled JavaScript entry at `dist/bin/index.js`.
+
+Check formatting and linting:
+
+```bash
+pnpm build
+pnpm format
+pnpm lint
+```
+
+Apply automatic fixes:
+
+```bash
+pnpm format:fix
+pnpm lint:fix
+```
+
+## Local Test
+
+Run the CLI from this repository:
+
+```bash
+pnpm build
+node dist/bin/index.js
+```
+
+Run without prompts:
+
+```bash
+pnpm build
+node dist/bin/index.js --name "My App" --id "com.example.my-app" --author "Your Name"
+```
+
+## Publish
+
+Build and inspect the npm package tarball contents through the `prepack` script. This compiles TypeScript to `dist/` and prepares the bundled template before packing:
+
+```bash
+pnpm pack --dry-run
+```
+
+Publish the package:
+
+```bash
+pnpm publish --access public
+```

package/assets/vscode-settings.json

@@ -0,0 +1,16 @@
+{
+    "explorer.fileNesting.enabled": true,
+    "explorer.fileNesting.patterns": {
+        "tsconfig.json": "tsconfig.*.json, env.d.ts, typed-router.d.ts",
+        "vite.config.*": "jsconfig*, vitest.config.*, cypress.config.*, playwright.config.*",
+        "package.json": "package-lock.json, pnpm*, .yarnrc*, yarn*, .eslint*, eslint*, .oxlint*, oxlint*, .oxfmt*, .prettier*, prettier*, .editorconfig"
+    },
+    "editor.codeActionsOnSave": {
+        "source.fixAll": "explicit"
+    },
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "oxc.oxc-vscode",
+    "[rust]": {
+        "editor.defaultFormatter": "rust-lang.rust-analyzer"
+    }
+}

package/dist/bin/index.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { basename, dirname, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { cac } from 'cac';
+import { color, printIntro } from '../cli/color.js';
+import { promptForMissingOptions } from '../cli/prompts.js';
+import { scaffoldProject } from '../cli/scaffold.js';
+import { requiredValue, toKebabCase, toSnakeCase, toTitleCase } from '../cli/text.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../../package.json');
+function parseCommand() {
+    const cli = cac('create-tauri-vue-template');
+    cli.usage('[project-dir] [options]')
+        .option('--name <name>', 'Application display name')
+        .option('--package <name>', 'Package name')
+        .option('--id <identifier>', 'Tauri application identifier')
+        .option('--author <name>', 'Project author')
+        .help()
+        .version(packageJson.version);
+    const parsed = cli.parse(process.argv, { run: false });
+    if (process.argv.includes('--help') || process.argv.includes('-h')) {
+        process.exit(0);
+    }
+    if (process.argv.includes('--version') || process.argv.includes('-v')) {
+        process.exit(0);
+    }
+    const options = parsed.options;
+    return {
+        projectDir: parsed.args[0],
+        options: {
+            name: options.name,
+            package: options.package,
+            id: options.id,
+            author: options.author,
+        },
+    };
+}
+async function main() {
+    const { projectDir, options } = parseCommand();
+    if (!projectDir && !options.name && (!process.stdin.isTTY || !process.stdout.isTTY)) {
+        throw new Error('Usage: pnpm create @duonghieu0712z/tauri-vue-template@latest [project-dir] --name "My App" --id "com.example.my-app"');
+    }
+    printIntro();
+    const defaultAppName = projectDir ? toTitleCase(basename(projectDir)) : 'Tauri Vue App';
+    const resolvedOptions = await promptForMissingOptions(options, {
+        appName: defaultAppName,
+    });
+    const appName = requiredValue(resolvedOptions.name?.trim() || defaultAppName, 'App name');
+    const packageName = requiredValue(resolvedOptions.package?.trim() || toKebabCase(appName), 'Package name');
+    const targetArg = projectDir || packageName;
+    const targetDir = resolve(process.cwd(), targetArg);
+    const crateName = toKebabCase(packageName);
+    const crateLibName = `${toSnakeCase(crateName)}_lib`;
+    const identifier = requiredValue(resolvedOptions.id?.trim() || `com.example.${packageName}`, 'Tauri identifier');
+    const author = resolvedOptions.author?.trim();
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const packageDir = resolve(currentDir, '..', '..');
+    await scaffoldProject(targetDir, packageDir, {
+        appName,
+        packageName,
+        crateName,
+        crateLibName,
+        identifier,
+        author,
+    });
+    const relativeTargetDir = relative(process.cwd(), targetDir) || '.';
+    console.log('');
+    console.log(`${color.green('Created')} ${appName} in ${color.cyan(relativeTargetDir)}`);
+    console.log('');
+    console.log(color.yellow('Next steps:'));
+    console.log(`  ${color.cyan(`cd ${relativeTargetDir}`)}`);
+    console.log(`  ${color.cyan('pnpm install')}`);
+    console.log(`  ${color.cyan('pnpm start')}`);
+}
+try {
+    await main();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+}

package/dist/cli/color.js

@@ -0,0 +1,25 @@
+import colors from 'picocolors';
+export const color = {
+    cyan: colors.cyan,
+    dim: colors.dim,
+    green: colors.green,
+    yellow: colors.yellow,
+};
+export function printIntro() {
+    if (!process.stdout.isTTY) {
+        return;
+    }
+    console.log('');
+    console.log(color.cyan('Tauri Vue Template'));
+    console.log(color.dim('Scaffold a Tauri 2 + Vue 3 desktop app.'));
+    console.log('');
+}
+export function printSection(title) {
+    if (!process.stdout.isTTY) {
+        return;
+    }
+    console.log(color.yellow(title));
+}
+export function formatPrompt(label, defaultValue) {
+    return `${label} ${color.dim(`(${defaultValue})`)}: `;
+}

package/dist/cli/files.js

@@ -0,0 +1,18 @@
+import { readFile, writeFile } from 'node:fs/promises';
+export async function readJson(path) {
+    return JSON.parse(await readFile(path, 'utf8'));
+}
+export async function writeJson(path, value) {
+    await writeFile(path, `${JSON.stringify(value, null, 4)}\n`);
+}
+export function replaceOne(content, pattern, replacement, description) {
+    if (!pattern.test(content)) {
+        throw new Error(`Could not update ${description}`);
+    }
+    return content.replace(pattern, replacement);
+}
+export async function updateText(path, replacements) {
+    const content = await readFile(path, 'utf8');
+    const updatedContent = replacements.reduce((currentContent, [pattern, replacement]) => replaceOne(currentContent, pattern, replacement, path), content);
+    await writeFile(path, updatedContent);
+}

package/dist/cli/project.js

@@ -0,0 +1,48 @@
+import { resolve } from 'node:path';
+import { readJson, updateText, writeJson } from './files.js';
+import { updateReleaseWorkflow } from './release-workflow.js';
+export async function renameProject(targetDir, identity) {
+    const packageJsonPath = resolve(targetDir, 'package.json');
+    const packageJson = await readJson(packageJsonPath);
+    packageJson.name = identity.packageName;
+    if (identity.author) {
+        packageJson.author = identity.author;
+    }
+    else {
+        delete packageJson.author;
+    }
+    await writeJson(packageJsonPath, packageJson);
+    const tauriConfigPath = resolve(targetDir, 'src-tauri', 'tauri.conf.json');
+    const tauriConfig = await readJson(tauriConfigPath);
+    tauriConfig.productName = identity.appName;
+    tauriConfig.identifier = identity.identifier;
+    tauriConfig.app.windows = tauriConfig.app.windows.map((window) => ({
+        ...window,
+        title: window.title ? identity.appName : window.title,
+    }));
+    if (identity.author) {
+        tauriConfig.bundle.publisher = identity.author;
+    }
+    else {
+        delete tauriConfig.bundle.publisher;
+    }
+    await writeJson(tauriConfigPath, tauriConfig);
+    await updateText(resolve(targetDir, 'index.html'), [
+        [/<title>.*<\/title>/, `<title>${identity.appName}</title>`],
+    ]);
+    await updateText(resolve(targetDir, 'src-tauri', 'Cargo.toml'), [
+        [/^name = "([^"]+)"/m, `name = "${identity.crateName}"`],
+        [/^description = "([^"]+)"/m, `description = "${identity.appName}"`],
+        [/^(\[lib\]\s+[\s\S]*?^name = )"([^"]+)"/m, `$1"${identity.crateLibName}"`],
+    ]);
+    await updateText(resolve(targetDir, 'src-tauri', 'Cargo.toml'), [
+        [
+            /^authors = \[[^\]]*\]/m,
+            identity.author ? `authors = ["${identity.author}"]` : 'authors = []',
+        ],
+    ]);
+    await updateText(resolve(targetDir, 'src-tauri', 'src', 'main.rs'), [
+        [/[a-zA-Z0-9_]+_lib::run\(\)/, `${identity.crateLibName}::run()`],
+    ]);
+    await updateReleaseWorkflow(resolve(targetDir, '.github', 'workflows', 'release.yml'), identity);
+}

package/dist/cli/prompts.js

@@ -0,0 +1,44 @@
+import { createInterface } from 'node:readline/promises';
+import { formatPrompt, printSection, color } from './color.js';
+import { toKebabCase } from './text.js';
+export async function promptForMissingOptions(options, defaults) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        const appName = options.name?.trim() || defaults.appName;
+        const packageName = options.package?.trim() || toKebabCase(appName);
+        return {
+            name: appName,
+            package: packageName,
+            id: options.id?.trim() || `com.example.${packageName}`,
+            author: options.author?.trim() || '',
+        };
+    }
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        printSection('Project identity');
+        const appName = options.name?.trim() ||
+            (await prompt.question(formatPrompt('App name', defaults.appName))).trim() ||
+            defaults.appName;
+        const defaultPackageName = toKebabCase(appName);
+        const packageName = options.package?.trim() ||
+            (await prompt.question(formatPrompt('Package name', defaultPackageName))).trim() ||
+            defaultPackageName;
+        const defaultIdentifier = `com.example.${packageName}`;
+        const identifier = options.id?.trim() ||
+            (await prompt.question(formatPrompt('Tauri identifier', defaultIdentifier))).trim() ||
+            defaultIdentifier;
+        const author = options.author?.trim() ||
+            (await prompt.question(`Author ${color.dim('(optional)')}: `)).trim();
+        return {
+            name: appName,
+            package: packageName,
+            id: identifier,
+            author,
+        };
+    }
+    finally {
+        prompt.close();
+    }
+}

package/dist/cli/release-workflow.js

@@ -0,0 +1,13 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { replaceOne } from './files.js';
+export async function updateReleaseWorkflow(path, identity) {
+    let content = await readFile(path, 'utf8');
+    content = replaceOne(content, /^(\s*releaseName:\s*).*$/m, `$1${identity.appName} v__VERSION__`, path);
+    if (/^\s*releaseAssetNamePattern:\s*/m.test(content)) {
+        content = replaceOne(content, /^(\s*releaseAssetNamePattern:\s*).*$/m, `$1${identity.packageName}_[version]_[arch][setup][ext]`, path);
+    }
+    else {
+        content = replaceOne(content, /^(\s*prerelease:\s*false)$/m, `$1\n          releaseAssetNamePattern: ${identity.packageName}_[version]_[arch][setup][ext]`, path);
+    }
+    await writeFile(path, content);
+}

package/dist/cli/scaffold.js

@@ -0,0 +1,30 @@
+import { access, copyFile, cp, mkdir, readdir } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { renameProject } from './project.js';
+export async function ensureEmptyTarget(path) {
+    await mkdir(path, { recursive: true });
+    const entries = await readdir(path);
+    if (entries.length > 0) {
+        throw new Error(`Target directory is not empty: ${path}`);
+    }
+}
+export async function ensureTemplate(templateDir) {
+    try {
+        await access(templateDir);
+    }
+    catch {
+        await import('../scripts/prepare-template.js');
+    }
+}
+export async function writeEditorSettings(targetDir, packageDir) {
+    await mkdir(resolve(targetDir, '.vscode'), { recursive: true });
+    await copyFile(resolve(packageDir, 'assets', 'vscode-settings.json'), resolve(targetDir, '.vscode', 'settings.json'));
+}
+export async function scaffoldProject(targetDir, packageDir, identity) {
+    const templateDir = resolve(packageDir, 'template');
+    await ensureTemplate(templateDir);
+    await ensureEmptyTarget(targetDir);
+    await cp(templateDir, targetDir, { recursive: true });
+    await writeEditorSettings(targetDir, packageDir);
+    await renameProject(targetDir, identity);
+}

package/dist/cli/text.js

@@ -0,0 +1,24 @@
+export function toKebabCase(value) {
+    return value
+        .trim()
+        .replace(/['"]/g, '')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+export function toSnakeCase(value) {
+    return toKebabCase(value).replaceAll('-', '_');
+}
+export function toTitleCase(value) {
+    return toKebabCase(value)
+        .split('-')
+        .filter(Boolean)
+        .map((word) => `${word[0].toUpperCase()}${word.slice(1)}`)
+        .join(' ');
+}
+export function requiredValue(value, name) {
+    if (!value) {
+        throw new Error(`${name} cannot be empty`);
+    }
+    return value;
+}

package/dist/cli/types.js

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

package/dist/scripts/prepare-template.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { createWriteStream } from 'node:fs';
+import { cp, mkdir, readdir, rm } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
+import { extract } from 'tar';
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const packageDir = resolve(currentDir, '..', '..');
+const templateDir = resolve(packageDir, 'template');
+const archivePath = resolve(packageDir, '.tmp-template.tar.gz');
+const templateRepo = process.env.TAURI_VUE_TEMPLATE_REPO || 'duonghieu0712z/tauri-vue-template';
+const templateRef = process.env.TAURI_VUE_TEMPLATE_REF || 'main';
+const templateSourceDir = process.env.TAURI_VUE_TEMPLATE_SOURCE
+    ? resolve(process.env.TAURI_VUE_TEMPLATE_SOURCE)
+    : null;
+const excludedPaths = new Set([
+    '.git',
+    '.eslintcache',
+    'dist',
+    'node_modules',
+    'packages',
+    'src-tauri/target',
+]);
+function normalizePath(path) {
+    return path.replaceAll('\\', '/');
+}
+function shouldInclude(relativePath) {
+    return !excludedPaths.has(normalizePath(relativePath));
+}
+async function copyTemplateSource(sourceDir) {
+    await mkdir(templateDir, { recursive: true });
+    await readdir(sourceDir).then((entries) => Promise.all(entries
+        .filter((entry) => shouldInclude(entry))
+        .map((entry) => cp(resolve(sourceDir, entry), resolve(templateDir, entry), {
+        recursive: true,
+        filter: (source) => shouldInclude(normalizePath(source).slice(normalizePath(sourceDir).length + 1)),
+    }))));
+}
+async function downloadTemplateArchive() {
+    const archiveUrl = `https://github.com/${templateRepo}/archive/${templateRef}.tar.gz`;
+    const response = await fetch(archiveUrl);
+    if (!response.ok || !response.body) {
+        throw new Error(`Could not download template archive: ${archiveUrl}`);
+    }
+    await pipeline(response.body, createWriteStream(archivePath));
+}
+async function extractTemplateArchive() {
+    await mkdir(templateDir, { recursive: true });
+    await extract({
+        file: archivePath,
+        cwd: templateDir,
+        strip: 1,
+        filter: (path) => shouldInclude(path.split('/').slice(1).join('/')),
+    });
+}
+await rm(templateDir, { recursive: true, force: true });
+await rm(archivePath, { force: true });
+if (templateSourceDir) {
+    await copyTemplateSource(templateSourceDir);
+}
+else {
+    await downloadTemplateArchive();
+    await extractTemplateArchive();
+    await rm(archivePath, { force: true });
+}
+console.log(`Prepared template at ${templateDir}`);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@duonghieu0712z/create-tauri-vue-template",
+  "version": "0.0.3",
+  "description": "Create a Tauri 2 + Vue 3 desktop app from the tauri-vue-template starter.",
+  "bin": {
+    "create-tauri-vue-template": "dist/bin/index.js"
+  },
+  "files": [
+    "assets",
+    "dist",
+    "template"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "picocolors": "^1.1.1",
+    "tar": "^7.5.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.1",
+    "oxfmt": "^0.51.0",
+    "oxlint": "^1.66.0",
+    "typescript": "~6.0.3"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "pnpm clean && tsc -p tsconfig.json",
+    "format": "oxfmt --check .",
+    "format:fix": "oxfmt .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix ."
+  }
+}

package/template/.editorconfig

@@ -0,0 +1,8 @@
+[*.{js,jsx,mjs,cjs,ts,tsx,mts,cts,vue,css,scss,sass,less,styl,html}]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 100
+trim_trailing_whitespace = true

package/template/.gitattributes

@@ -0,0 +1,5 @@
+* text=auto eol=lf
+
+pnpm-lock.yaml linguist-generated=true
+src-tauri/Cargo.lock linguist-generated=true
+src/generated/**/*.ts linguist-generated=true

package/template/.github/dependabot.yml

@@ -0,0 +1,38 @@
+version: 2
+
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+      time: '02:00'
+      timezone: Etc/UTC
+    open-pull-requests-limit: 10
+    groups:
+      npm-minor-and-patch:
+        update-types:
+          - minor
+          - patch
+
+  - package-ecosystem: cargo
+    directory: /src-tauri
+    schedule:
+      interval: weekly
+      day: monday
+      time: '02:30'
+      timezone: Etc/UTC
+    open-pull-requests-limit: 10
+    groups:
+      cargo-minor-and-patch:
+        update-types:
+          - minor
+          - patch
+
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+      time: '03:00'
+      timezone: Etc/UTC

package/template/.github/workflows/code-quality.yml

@@ -0,0 +1,70 @@
+name: Code Quality
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+env:
+  NODE_VERSION: '24'
+  PNPM_VERSION: '11'
+
+jobs:
+  frontend:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+        with:
+          version: ${{ env.PNPM_VERSION }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: pnpm
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Check formatting
+        run: pnpm format
+
+      - name: Check lint
+        run: pnpm lint
+
+  rust:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Install Linux dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
+
+      - name: Setup Rust
+        uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: rustfmt, clippy
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: './src-tauri -> target'
+
+      - name: Check formatting
+        run: cargo fmt --manifest-path src-tauri/Cargo.toml -- --check
+
+      - name: Check lint
+        run: cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets --all-features -- -D warnings