@tsparticles/cli-command-create-app 4.1.3

package/.browserslistrc

@@ -0,0 +1,2 @@
+since 2021
+not dead

package/.dependency-cruiser.cjs

@@ -0,0 +1,230 @@
+/** @type {import('dependency-cruiser').IConfiguration} */
+module.exports = {
+  forbidden: [
+    {
+      name: 'no-circular',
+      severity: 'warn',
+      comment:
+        "This dependency is part of a circular relationship. You might want to revise " +
+        "your solution (i.e. use dependency inversion, make sure the modules have a single responsibility) ",
+      from: {},
+      to: {
+        circular: true
+      }
+    },
+    {
+      name: 'no-orphans',
+      comment:
+        "This is an orphan module - it's likely not used (anymore?). Either use it or " +
+        "remove it. If it's logical this module is an orphan (i.e. it's a config file), " +
+        "add an exception for it in your dependency-cruiser configuration. By default " +
+        "this rule does not scrutinize dot-files (e.g. .eslintrc.js), TypeScript declaration " +
+        "files (.d.ts), tsconfig.json and some of the babel and webpack configs.",
+      severity: 'warn',
+      from: {
+        orphan: true,
+        pathNot: [
+          '(^|/)[.][^/]+[.](?:js|cjs|mjs|ts|cts|mts|json)$',
+          '[.]d[.]ts$',
+          '(^|/)tsconfig[.]json$',
+          '(^|/)(?:babel|webpack)[.]config[.](?:js|cjs|mjs|ts|cts|mts|json)$'
+        ]
+      },
+      to: {},
+    },
+    {
+      name: 'no-deprecated-core',
+      comment:
+        'A module depends on a node core module that has been deprecated. Find an alternative - these are ' +
+        "bound to exist - node doesn't deprecate lightly.",
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'core'
+        ],
+        path: [
+          '^v8/tools/codemap$',
+          '^v8/tools/consarray$',
+          '^v8/tools/csvparser$',
+          '^v8/tools/logreader$',
+          '^v8/tools/profile_view$',
+          '^v8/tools/profile$',
+          '^v8/tools/SourceMap$',
+          '^v8/tools/splaytree$',
+          '^v8/tools/tickprocessor-driver$',
+          '^v8/tools/tickprocessor$',
+          '^node-inspect/lib/_inspect$',
+          '^node-inspect/lib/internal/inspect_client$',
+          '^node-inspect/lib/internal/inspect_repl$',
+          '^async_hooks$',
+          '^punycode$',
+          '^domain$',
+          '^constants$',
+          '^sys$',
+          '^_linklist$',
+          '^_stream_wrap$'
+        ],
+      }
+    },
+    {
+      name: 'not-to-deprecated',
+      comment:
+        'This module uses a (version of an) npm module that has been deprecated. Either upgrade to a later ' +
+        'version of that module, or find an alternative. Deprecated modules are a security risk.',
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'deprecated'
+        ]
+      }
+    },
+    {
+      name: 'no-non-package-json',
+      severity: 'error',
+      comment:
+        "This module depends on an npm package that isn't in the 'dependencies' section of your package.json. " +
+        "That's problematic as the package either (1) won't be available on live (2 - worse) will be " +
+        "available on live with an non-guaranteed version. Fix it by adding the package to the dependencies " +
+        "in your package.json.",
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-no-pkg',
+          'npm-unknown'
+        ]
+      }
+    },
+    {
+      name: 'not-to-unresolvable',
+      comment:
+        "This module depends on a module that cannot be found ('resolved to disk'). If it's an npm " +
+        'module: add it to your package.json. In all other cases you likely already know what to do.',
+      severity: 'error',
+      from: {},
+      to: {
+        couldNotResolve: true
+      }
+    },
+    {
+      name: 'no-duplicate-dep-types',
+      comment:
+        "Likely this module depends on an external ('npm') package that occurs more than once " +
+        "in your package.json i.e. bot as a devDependencies and in dependencies. This will cause " +
+        "maintenance problems later on.",
+      severity: 'warn',
+      from: {},
+      to: {
+        moreThanOneDependencyType: true,
+        dependencyTypesNot: ["type-only"]
+      }
+    },
+    {
+      name: 'not-to-test',
+      comment:
+        "This module depends on code within a folder that should only contain tests. As tests don't " +
+        "implement functionality this is odd. Either you're writing a test outside the test folder " +
+        "or there's something in the test folder that isn't a test.",
+      severity: 'error',
+      from: {
+        pathNot: '^(tests)'
+      },
+      to: {
+        path: '^(tests)'
+      }
+    },
+    {
+      name: 'not-to-spec',
+      comment:
+        'This module depends on a spec (test) file. The responsibility of a spec file is to test code. ' +
+        "If there's something in a spec that's of use to other modules, it doesn't have that single " +
+        'responsibility anymore. Factor it out into (e.g.) a separate utility/ helper or a mock.',
+      severity: 'error',
+      from: {},
+      to: {
+        path: '[.](?:spec|test)[.](?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$'
+      }
+    },
+    {
+      name: 'not-to-dev-dep',
+      severity: 'error',
+      comment:
+        "This module depends on an npm package from the 'devDependencies' section of your " +
+        'package.json. It looks like something that ships to production, though. To prevent problems ' +
+        "with npm packages that aren't there on production declare it (only!) in the 'dependencies'" +
+        'section of your package.json. If this module is development only - add it to the ' +
+        'from.pathNot re of the not-to-dev-dep rule in the dependency-cruiser configuration',
+      from: {
+        path: '^(src)',
+        pathNot: '[.](?:spec|test)[.](?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$'
+      },
+      to: {
+        dependencyTypes: [
+          'npm-dev',
+        ],
+        dependencyTypesNot: [
+          'type-only'
+        ],
+        pathNot: [
+          'node_modules/@types/'
+        ]
+      }
+    },
+    {
+      name: 'optional-deps-used',
+      severity: 'info',
+      comment:
+        "This module depends on an npm package that is declared as an optional dependency " +
+        "in your package.json. As this makes sense in limited situations only, it's flagged here. " +
+        "If you use an optional dependency here by design - add an exception to your" +
+        "dependency-cruiser configuration.",
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-optional'
+        ]
+      }
+    },
+    {
+      name: 'peer-deps-used',
+      comment:
+        "This module depends on an npm package that is declared as a peer dependency " +
+        "in your package.json. This makes sense if your package is e.g. a plugin, but in " +
+        "other cases - maybe not so much. If the use of a peer dependency is intentional " +
+        "add an exception to your dependency-cruiser configuration.",
+      severity: 'warn',
+      from: {},
+      to: {
+        dependencyTypes: [
+          'npm-peer'
+        ]
+      }
+    }
+  ],
+  options: {
+    doNotFollow: {
+      path: ['node_modules']
+    },
+    tsConfig: {
+      fileName: 'src/tsconfig.json'
+    },
+    enhancedResolveOptions: {
+      exportsFields: ['exports'],
+      conditionNames: ['import', 'require', 'node', 'default', 'types'],
+      mainFields: ["module", "main", "types", "typings"],
+    },
+    skipAnalysisNotInRules: true,
+    reporterOptions: {
+      dot: {
+        collapsePattern: 'node_modules/(?:@[^/]+/[^/]+|[^/]+)',
+      },
+      archi: {
+        collapsePattern: '^(?:packages|src|lib(s?)|app(s?)|bin|test(s?)|spec(s?))/[^/]+|node_modules/(?:@[^/]+/[^/]+|[^/]+)',
+      },
+      text: {
+        highlightFocused: true
+      },
+    }
+  }
+};

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Matteo Bruni
+
+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,11 @@
+# @tsparticles/cli-command-create-app
+
+## Build
+
+```bash
+pnpm run build
+```
+
+## License
+
+MIT

package/dist/app.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+declare const appCreateCommand: Command;
+export { appCreateCommand };

package/dist/app.js

@@ -0,0 +1,28 @@
+import { promptAppData } from "./prompts.js";
+import { Command } from "commander";
+import { createAppProject } from "./scaffold.js";
+const appCreateCommand = new Command("app");
+appCreateCommand.description("Create a new tsParticles app from a template");
+appCreateCommand.argument("[destination]", "Destination folder (defaults to project name)");
+appCreateCommand.option("--framework <name>", "Framework (vanilla|react|vue3|angular|svelte|solid)");
+appCreateCommand.option("--skip-install", "Skip npm install after scaffolding");
+appCreateCommand.option("--template <name>", "Template to use (scaffold|login|portfolio|landing|tictactoe|confetti|ribbons|particles)");
+appCreateCommand.action(async (destination, options) => {
+    const destArg = destination ?? "tsparticles-app", template = options.template, framework = options.framework, skipInstall = options.skipInstall ?? false, data = await promptAppData(destArg, {
+        framework,
+        projectName: undefined,
+        useCase: template,
+    }), result = await createAppProject({
+        destination: data.destinationPath,
+        framework: data.framework,
+        projectName: data.projectName,
+        skipInstall,
+        useCase: data.useCase,
+    });
+    console.log(`\nProject created successfully at ${result.targetDir}`);
+    console.log("Run the following commands to get started:\n");
+    console.log(`  cd ${result.targetDir}`);
+    console.log(skipInstall ? "  npm install" : "");
+    console.log("  npm run dev\n");
+});
+export { appCreateCommand };

package/dist/prompts.d.ts

@@ -0,0 +1,21 @@
+export type Framework = "vanilla" | "react" | "vue3" | "angular" | "svelte" | "solid";
+export type UseCase = "none" | "login" | "portfolio" | "landing" | "tictactoe" | "confetti" | "ribbons" | "particles";
+export interface IAppPromptResult {
+    destinationPath: string;
+    framework: Framework;
+    projectName: string;
+    useCase: UseCase;
+}
+/**
+ *
+ * @param destination
+ * @param prefill
+ * @param prefill.framework
+ * @param prefill.projectName
+ * @param prefill.useCase
+ */
+export declare function promptAppData(destination: string, prefill?: {
+    framework?: Framework;
+    projectName?: string;
+    useCase?: UseCase;
+}): Promise<IAppPromptResult>;

package/dist/prompts.js

@@ -0,0 +1,75 @@
+import { getDestinationDir, getRepositoryUrl } from "@tsparticles/cli-create-utils";
+import path from "node:path";
+import prompts from "prompts";
+const initialFrameworkIndex = 0, initialUseCaseIndex = 0, frameworkChoices = [
+    { title: "Vanilla (Vite + TypeScript)", value: "vanilla" },
+    { title: "React", value: "react" },
+    { title: "Vue 3", value: "vue3" },
+    { title: "Angular", value: "angular" },
+    { title: "Svelte", value: "svelte" },
+    { title: "Solid", value: "solid" },
+], useCaseChoices = [
+    { title: "None (just the scaffold)", value: "none" },
+    { title: "Login / Register", value: "login" },
+    { title: "Portfolio", value: "portfolio" },
+    { title: "Landing Page", value: "landing" },
+    { title: "Tic Tac Toe", value: "tictactoe" },
+    { title: "Confetti", value: "confetti" },
+    { title: "Ribbons", value: "ribbons" },
+    { title: "Particles", value: "particles" },
+];
+/**
+ *
+ * @param destination
+ * @param prefill
+ * @param prefill.framework
+ * @param prefill.projectName
+ * @param prefill.useCase
+ */
+export async function promptAppData(destination, prefill) {
+    const destinationPath = await getDestinationDir(destination), repositoryUrl = await getRepositoryUrl(), initialName = destinationPath.split(path.sep).pop() ?? "tsparticles-app";
+    void repositoryUrl;
+    const questions = [];
+    if (!prefill?.projectName) {
+        questions.push({
+            type: "text",
+            name: "projectName",
+            message: "What is the project name?",
+            validate: (value) => (value ? true : "The project name can't be empty"),
+            initial: initialName,
+        });
+    }
+    if (!prefill?.framework) {
+        questions.push({
+            type: "select",
+            name: "framework",
+            message: "Which framework would you like to use?",
+            choices: frameworkChoices,
+            initial: initialFrameworkIndex,
+        });
+    }
+    if (!prefill?.useCase) {
+        questions.push({
+            type: "select",
+            name: "useCase",
+            message: "Which use-case template would you like to include?",
+            choices: useCaseChoices,
+            initial: initialUseCaseIndex,
+        });
+    }
+    if (!questions.length) {
+        return {
+            destinationPath,
+            framework: prefill?.framework ?? "vanilla",
+            projectName: prefill?.projectName ?? initialName,
+            useCase: prefill?.useCase ?? "none",
+        };
+    }
+    const answers = (await prompts(questions));
+    return {
+        destinationPath,
+        framework: prefill?.framework ?? answers.framework ?? "vanilla",
+        projectName: (prefill?.projectName ?? answers.projectName ?? initialName).trim(),
+        useCase: prefill?.useCase ?? answers.useCase ?? "none",
+    };
+}

package/dist/scaffold.d.ts

@@ -0,0 +1,10 @@
+import type { ScaffoldResult, UserOptions } from "./types.js";
+import type { Framework, UseCase } from "./prompts.js";
+/**
+ *
+ * @param options
+ */
+export declare function createAppProject(options: UserOptions & {
+    framework: Framework;
+    useCase: UseCase;
+}): Promise<ScaffoldResult>;

package/dist/scaffold.js

@@ -0,0 +1,128 @@
+/* eslint-disable sort-imports */
+import { runInstall, dash } from "@tsparticles/cli-create-utils";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { resolveEngineVersion, resolveTemplateRoot } from "./template-resolver.js";
+const jsonIndentation = 2, useCaseTemplateNames = {
+    none: undefined,
+    login: "login",
+    portfolio: "portfolio",
+    landing: "landing",
+    tictactoe: "tictactoe",
+    confetti: "confetti",
+    ribbons: "ribbons",
+    particles: "particles",
+};
+/**
+ *
+ * @param options
+ */
+export async function createAppProject(options) {
+    const { projectName, framework, skipInstall, useCase } = options, targetDir = options.destination, packageName = dash(projectName), version = resolveEngineVersion(), replacements = {
+        "{{projectName}}": projectName,
+        "{{packageName}}": packageName,
+        "{{version}}": version,
+    };
+    let mergedDeps = {};
+    const scaffoldRoot = resolveTemplateRoot("scaffold"), scaffoldDeps = await readTemplateJson(scaffoldRoot);
+    if (scaffoldDeps) {
+        mergedDeps = deepMergeDeps(mergedDeps, scaffoldDeps);
+    }
+    const scaffoldSource = path.join(scaffoldRoot, "template", framework);
+    if (!existsSync(path.join(scaffoldSource, "package.json"))) {
+        throw new Error(`Scaffold template not found for framework "${framework}". Looked at: ${scaffoldSource}. Available frameworks: check template directories.`);
+    }
+    await mkdir(targetDir, { recursive: true });
+    await copyAndReplace(scaffoldSource, targetDir, replacements);
+    if (useCase !== "none") {
+        const ucTemplateName = useCaseTemplateNames[useCase];
+        if (ucTemplateName) {
+            const ucRoot = resolveTemplateRoot(ucTemplateName), ucDeps = await readTemplateJson(ucRoot);
+            if (ucDeps) {
+                mergedDeps = deepMergeDeps(mergedDeps, ucDeps);
+            }
+            const ucSource = path.join(ucRoot, "template", framework);
+            if (existsSync(path.join(ucSource, "package.json"))) {
+                await copyAndReplace(ucSource, targetDir, replacements);
+            }
+        }
+    }
+    if (mergedDeps.dependencies || mergedDeps.devDependencies) {
+        const pkgJsonPath = path.join(targetDir, "package.json"), pkg = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+        if (mergedDeps.dependencies) {
+            const existingDeps = (pkg.dependencies ?? {});
+            pkg.dependencies = { ...mergedDeps.dependencies, ...existingDeps };
+        }
+        if (mergedDeps.devDependencies) {
+            const existingDevDeps = (pkg.devDependencies ?? {});
+            pkg.devDependencies = { ...mergedDeps.devDependencies, ...existingDevDeps };
+        }
+        await writeFile(pkgJsonPath, `${JSON.stringify(pkg, undefined, jsonIndentation)}\n`);
+    }
+    if (!skipInstall) {
+        await runInstall(targetDir);
+    }
+    return {
+        frameworkUsed: framework,
+        targetDir,
+        templateUsed: useCase === "none" ? "scaffold" : useCase,
+    };
+}
+/**
+ *
+ * @param templateRoot
+ */
+async function readTemplateJson(templateRoot) {
+    const templateJsonPath = path.join(templateRoot, "template.json");
+    if (!existsSync(templateJsonPath)) {
+        return null;
+    }
+    const content = JSON.parse(await readFile(templateJsonPath, "utf-8"));
+    return content.package ?? null;
+}
+/**
+ *
+ * @param src
+ * @param dest
+ * @param replacements
+ */
+async function copyAndReplace(src, dest, replacements) {
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        let destName = entry.name;
+        if (destName === "gitignore") {
+            destName = ".gitignore";
+        }
+        const destPath = path.join(dest, destName);
+        if (entry.isDirectory()) {
+            await mkdir(destPath, { recursive: true });
+            await copyAndReplace(srcPath, destPath, replacements);
+        }
+        else {
+            let content = await readFile(srcPath, "utf-8");
+            for (const [key, value] of Object.entries(replacements)) {
+                content = content.replaceAll(key, value);
+            }
+            await writeFile(destPath, content);
+        }
+    }
+}
+/**
+ *
+ * @param target
+ * @param source
+ */
+function deepMergeDeps(target, source) {
+    return {
+        dependencies: {
+            ...(target.dependencies ?? {}),
+            ...(source.dependencies ?? {}),
+        },
+        devDependencies: {
+            ...(target.devDependencies ?? {}),
+            ...(source.devDependencies ?? {}),
+        },
+    };
+}

package/dist/template-resolver.d.ts

@@ -0,0 +1,19 @@
+import type { TemplateInfo } from "./types.js";
+/**
+ *
+ * @param name
+ */
+export declare function resolveTemplateRoot(name: string): string;
+/**
+ *
+ * @param templateName
+ */
+export declare function listAvailableFrameworks(templateName: string): string[];
+/**
+ *
+ */
+export declare function listAvailableTemplates(): TemplateInfo[];
+/**
+ *
+ */
+export declare function resolveEngineVersion(): string;

package/dist/template-resolver.js

@@ -0,0 +1,88 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+const __filename = fileURLToPath(import.meta.url), __dirname = path.dirname(__filename), repoRoot = path.resolve(__dirname, "..", "..", "..", ".."), workspaceTemplateRoot = path.join(repoRoot, "templates"), isWorkspaceMode = existsSync(path.join(workspaceTemplateRoot, "scaffold", "package.json"));
+/**
+ *
+ * @param name
+ */
+export function resolveTemplateRoot(name) {
+    if (isWorkspaceMode) {
+        const workspacePath = path.join(workspaceTemplateRoot, name);
+        if (existsSync(path.join(workspacePath, "package.json"))) {
+            return workspacePath;
+        }
+    }
+    const nodeModulesPath = path.join(repoRoot, "node_modules", `@tsparticles/template-${name}`), hoistedPath = path.join(repoRoot, "..", "node_modules", `@tsparticles/template-${name}`);
+    for (const candidate of [nodeModulesPath, hoistedPath]) {
+        if (existsSync(path.join(candidate, "package.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error(`Template "${name}" not found. Looked in workspace (${path.join(workspaceTemplateRoot, name)}) and installed packages.`);
+}
+/**
+ *
+ * @param templateName
+ */
+export function listAvailableFrameworks(templateName) {
+    const templateRoot = resolveTemplateRoot(templateName), frameworksDir = path.join(templateRoot, "template");
+    if (!existsSync(frameworksDir)) {
+        return [];
+    }
+    const entries = readdirSync(frameworksDir), result = [];
+    for (const entry of entries) {
+        if (existsSync(path.join(frameworksDir, entry, "package.json"))) {
+            result.push(entry);
+        }
+    }
+    return result.sort();
+}
+/**
+ *
+ */
+export function listAvailableTemplates() {
+    const templateMap = {
+        scaffold: { displayName: "Scaffold", type: "scaffold" },
+        login: { displayName: "Login Page", type: "example" },
+        portfolio: { displayName: "Portfolio", type: "example" },
+        landing: { displayName: "Landing Page", type: "example" },
+        tictactoe: { displayName: "Tic Tac Toe", type: "example" },
+        confetti: { displayName: "Confetti", type: "example" },
+        ribbons: { displayName: "Ribbons", type: "example" },
+        particles: { displayName: "Particles", type: "example" },
+    }, results = [];
+    for (const [name, info] of Object.entries(templateMap)) {
+        try {
+            const frameworks = listAvailableFrameworks(name);
+            results.push({
+                displayName: info.displayName,
+                frameworks,
+                name,
+                type: info.type,
+            });
+        }
+        catch {
+            // template not available, skip
+        }
+    }
+    return results;
+}
+/**
+ *
+ */
+export function resolveEngineVersion() {
+    if (isWorkspaceMode) {
+        const enginePkgPath = path.join(repoRoot, "engine", "package.json");
+        if (existsSync(enginePkgPath)) {
+            const pkg = JSON.parse(readFileSync(enginePkgPath, "utf-8"));
+            return pkg.version ?? "4.1.3";
+        }
+    }
+    const enginePkgPath = path.join(repoRoot, "node_modules", "@tsparticles", "engine", "package.json");
+    if (existsSync(enginePkgPath)) {
+        const pkg = JSON.parse(readFileSync(enginePkgPath, "utf-8"));
+        return pkg.version ?? "4.1.3";
+    }
+    return "4.1.3";
+}