rs3-api-ts 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("node:path"));
+const build_1 = require("./build");
+const dev_1 = require("./dev");
+const init_1 = require("./init");
+const report_1 = require("./report");
+const permissions_1 = require("./permissions");
+const project_1 = require("./project");
+const BOOLEAN_FLAGS = new Set([
+    "dev", "help", "version", "quiet", "yes", "sync-version", "no-sync-version", "local", "registry",
+    "settings-icon", "no-settings-icon", "ribbon-icon", "no-ribbon-icon",
+]);
+function parseArgs(argv) {
+    const flags = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith("--")) {
+            positional.push(arg);
+            continue;
+        }
+        const key = arg.slice(2);
+        const next = argv[i + 1];
+        if (BOOLEAN_FLAGS.has(key) || next === undefined || next.startsWith("--")) {
+            flags[key] = true;
+        }
+        else {
+            flags[key] = next;
+            i++;
+        }
+    }
+    return { flags, positional };
+}
+function usage() {
+    return [
+        `rs3-plugin ${(0, project_1.sdkVersion)()}`,
+        "",
+        "Usage:",
+        "  rs3-plugin init [name]            scaffold a new plugin in ./<name> (asks what it does not know)",
+        "  rs3-plugin build [--out <dir>]    compile src/ to readable Lua in dist/ and run checks",
+        "  rs3-plugin build --dev            single-file bundle with source-mapped tracebacks",
+        "  rs3-plugin dev [--out <dir>]      rebuild on change (dev mode)",
+        "",
+        "Options:",
+        "  --out <dir>    copy the built plugin into <dir>/<plugin name>/ (your client's plugin folder)",
+        "  --cwd <dir>    run as if started from <dir>",
+        "  --quiet        only print problems",
+        "",
+        "init answers (skip the prompts):",
+        "  --yes                         accept defaults for anything not given",
+        "  --permissions <a,b>           required permissions (default none)",
+        "  --optional-permissions <a,b>  optional permissions (default none)",
+        "  --urls <list>                 comma-separated, each `name=url` or a bare url (named api, api2, ...);",
+        "                                asked for when a chosen permission needs urls",
+        "  --deps <list>                 required library plugins from mod.io: `prettyui` (known name) or `name=<mod.io id>`",
+        "  --optional-deps <list>        same, for optional dependencies",
+        "  --settings-icon | --no-settings-icon",
+        "  --ribbon-icon | --no-ribbon-icon",
+        "                                plugin.json hasSettingsIcon / hasRibbonIcon (default no)",
+        "  --contact-email <address>     plugin.json contactEmailAddress (default none)",
+        "  --plugin-version <x.y.z>      initial version (default 0.1.0)",
+        "  --sync-version | --no-sync-version",
+        "                                keep plugin.json's version equal to package.json's (default yes)",
+        "  --local | --registry          depend on this SDK checkout (file:...) or on the npm package (^version);",
+        "                                default: local when run from a checkout, registry when installed",
+        "",
+        `known permissions: ${(0, permissions_1.permissionNames)().join(", ")}`,
+    ].join("\n");
+}
+function stringFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+/** `--name` -> true, `--no-name` -> false, neither -> undefined (ask or default). */
+function tristate(flags, name) {
+    if (flags[`no-${name}`] === true) {
+        return false;
+    }
+    if (flags[name] === true) {
+        return true;
+    }
+    return undefined;
+}
+/** `--flag a,b,c` -> ["a", "b", "c"]; a bare `--flag` means an empty list. */
+function listFlag(flags, name) {
+    const value = flags[name];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        return [];
+    }
+    return value
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s !== "");
+}
+async function main() {
+    const { flags, positional } = parseArgs(process.argv.slice(2));
+    const command = positional[0];
+    const cwd = path.resolve(stringFlag(flags, "cwd") ?? process.cwd());
+    if (flags.version === true) {
+        console.log((0, project_1.sdkVersion)());
+        return;
+    }
+    if (command === undefined || flags.help === true) {
+        console.log(usage());
+        process.exitCode = flags.help === true ? 0 : 1;
+        return;
+    }
+    switch (command) {
+        case "build": {
+            const result = (0, build_1.build)({
+                cwd,
+                dev: flags.dev === true,
+                deployTo: stringFlag(flags, "out"),
+            });
+            (0, report_1.printProblems)(result.problems);
+            if (flags.quiet !== true) {
+                (0, report_1.printSummary)(result);
+            }
+            process.exitCode = result.ok ? 0 : 1;
+            return;
+        }
+        case "dev": {
+            (0, dev_1.dev)({ cwd, deployTo: stringFlag(flags, "out") });
+            return;
+        }
+        case "init": {
+            await (0, init_1.init)({
+                cwd,
+                interactive: flags.yes !== true && process.stdin.isTTY === true,
+                answers: {
+                    name: positional[1],
+                    requiredPermissions: listFlag(flags, "permissions"),
+                    optionalPermissions: listFlag(flags, "optional-permissions"),
+                    urls: stringFlag(flags, "urls") ?? stringFlag(flags, "api-url"),
+                    requiredDependencies: (0, init_1.dependenciesFromFlag)(stringFlag(flags, "deps"), "--deps"),
+                    optionalDependencies: (0, init_1.dependenciesFromFlag)(stringFlag(flags, "optional-deps"), "--optional-deps"),
+                    settingsIcon: tristate(flags, "settings-icon"),
+                    ribbonIcon: tristate(flags, "ribbon-icon"),
+                    contactEmail: stringFlag(flags, "contact-email"),
+                    version: stringFlag(flags, "plugin-version"),
+                    syncVersion: tristate(flags, "sync-version"),
+                    sdkSource: flags.registry === true ? "registry" : flags.local === true ? "local" : undefined,
+                },
+            });
+            return;
+        }
+        default:
+            console.error(`error: unknown command "${command}"\n`);
+            console.log(usage());
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    (0, report_1.printError)(error);
+    process.exitCode = 1;
+});

package/dist/init.js

@@ -0,0 +1,427 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+exports.dependenciesFromFlag = dependenciesFromFlag;
+exports.parseUrls = parseUrls;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("./errors");
+const libraries_1 = require("./libraries");
+const permissions_1 = require("./permissions");
+const prompt_1 = require("./prompt");
+const project_1 = require("./project");
+const NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+const VERSION_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/;
+const RENAMES = {
+    _gitignore: ".gitignore",
+};
+const DEFAULTS = {
+    version: "0.1.0",
+    syncVersion: true,
+};
+async function init(options) {
+    const answers = await collectAnswers(options.answers, options.interactive);
+    const target = path.join(options.cwd, answers.name);
+    if (fs.existsSync(target) && fs.readdirSync(target).length > 0) {
+        throw new errors_1.CliError(`${answers.name} already exists here and is not empty`, [
+            `nothing was written to ${target}`,
+            "scaffold under a different name, or empty that folder first",
+        ]);
+    }
+    const written = [];
+    const write = (relative, content) => {
+        const to = path.join(target, relative);
+        fs.mkdirSync(path.dirname(to), { recursive: true });
+        fs.writeFileSync(to, content);
+        written.push(relative);
+    };
+    const dependencies = sdkDependencies(answers, target);
+    write("package.json", `${JSON.stringify(packageJson(answers, dependencies), null, 2)}\n`);
+    write("plugin.json", `${JSON.stringify(pluginJson(answers), null, 2)}\n`);
+    copyTemplates(path.join((0, project_1.sdkRoot)(), "templates"), answers, write);
+    console.log(`\ncreated ${answers.name}/ with ${written.length} files`);
+    if (answers.sdkSource === "local") {
+        console.log(`SDK packages are referenced from this checkout (${dependencies["rs3-api-ts"]}); pass --registry to depend on the published packages instead`);
+    }
+    if (answers.syncVersion) {
+        console.log("plugin.json follows package.json's version: bump with `npm version patch|minor|major`");
+    }
+    console.log("\nnext steps:");
+    console.log(`  cd ${answers.name}`);
+    console.log("  npm install");
+    console.log("  npm run build          # readable Lua in dist/");
+    console.log("  npm run dev -- --out <your client's plugins folder>");
+}
+async function collectAnswers(given, interactive) {
+    validatePermissionList(given.requiredPermissions, "--permissions");
+    validatePermissionList(given.optionalPermissions, "--optional-permissions");
+    const name = await resolveText(interactive, given.name, "Plugin name (folder, package and plugin id)", undefined, validateName, NAME_HINT);
+    let required = given.requiredPermissions;
+    let optional = given.optionalPermissions;
+    if (required === undefined && optional === undefined && interactive) {
+        required = await selectPermissions("Permissions the plugin needs", (0, permissions_1.permissionNames)(), []);
+        const remaining = (0, permissions_1.permissionNames)().filter((p) => !required.includes(p));
+        optional = remaining.length > 0 ? await selectPermissions("Optional permissions (the user can grant or refuse them)", remaining, []) : [];
+    }
+    required = required ?? [];
+    optional = (optional ?? []).filter((p) => !required.includes(p));
+    let urls = given.urls;
+    const needsUrls = [...required, ...optional].some((p) => (0, permissions_1.findPermission)(p)?.needsUrls === true);
+    if (urls !== undefined) {
+        const error = validateUrls(urls);
+        if (error !== undefined) {
+            throw new errors_1.CliError(`--urls: ${error}`, [
+                "comma separated, each entry either a url or name=url",
+                'for example: --urls "https://api.example.com/, wiki=https://runescape.wiki/"',
+            ]);
+        }
+    }
+    else if (needsUrls) {
+        urls = await resolveText(interactive, undefined, "URLs the plugin may call, comma separated (name=url or just url)", "https://example.com/", validateUrls);
+    }
+    let requiredDeps = given.requiredDependencies;
+    let optionalDeps = given.optionalDependencies;
+    if (requiredDeps === undefined && optionalDeps === undefined && interactive) {
+        const catalog = (0, libraries_1.loadCatalog)();
+        if (catalog.libraries.length > 0) {
+            const stamp = catalog.generatedAt !== null ? `list from ${catalog.generatedAt.slice(0, 10)}` : "hand-seeded list";
+            requiredDeps = await selectLibraries(`Library plugins from mod.io the plugin requires (${stamp})`, catalog.libraries);
+            const chosen = new Set(requiredDeps.map((d) => d.name));
+            const remaining = catalog.libraries.filter((lib) => !chosen.has(lib.name_id));
+            optionalDeps = remaining.length > 0 ? await selectLibraries("Optional library plugins (used when installed)", remaining) : [];
+        }
+    }
+    requiredDeps = requiredDeps ?? [];
+    const requiredNames = new Set(requiredDeps.map((d) => d.name));
+    optionalDeps = (optionalDeps ?? []).filter((d) => !requiredNames.has(d.name));
+    let settingsIcon = given.settingsIcon;
+    let ribbonIcon = given.ribbonIcon;
+    if (settingsIcon === undefined && ribbonIcon === undefined && interactive) {
+        const picked = await (0, prompt_1.multiSelect)("Client integration", [
+            { label: "settings icon", hint: "hasSettingsIcon: the plugin appears in the settings panel" },
+            { label: "ribbon icon", hint: "hasRibbonIcon: the plugin gets a button on the ribbon" },
+        ]);
+        settingsIcon = picked[0];
+        ribbonIcon = picked[1];
+    }
+    settingsIcon = settingsIcon ?? false;
+    ribbonIcon = ribbonIcon ?? false;
+    let contactEmail = given.contactEmail;
+    if (contactEmail !== undefined) {
+        const error = validateEmail(contactEmail);
+        if (error !== undefined) {
+            throw new errors_1.CliError(`--contact-email: ${error}`, ["for example: --contact-email you@example.com"]);
+        }
+    }
+    else if (interactive) {
+        contactEmail = await (0, prompt_1.text)("Contact email for plugin.json (enter to skip)", "", validateEmail);
+    }
+    if (contactEmail === "") {
+        contactEmail = undefined;
+    }
+    const version = await resolveText(interactive, given.version, "Version", DEFAULTS.version, validateVersion, [
+        "for example: --plugin-version 1.0.0",
+    ]);
+    const syncVersion = await resolveBoolean(interactive, given.syncVersion, "Should plugin.json's version follow package.json's version?", DEFAULTS.syncVersion);
+    const sdkSource = given.sdkSource ?? (isInstalledFromRegistry() ? "registry" : "local");
+    return {
+        name,
+        requiredPermissions: required,
+        optionalPermissions: optional,
+        urls,
+        requiredDependencies: requiredDeps,
+        optionalDependencies: optionalDeps,
+        settingsIcon,
+        ribbonIcon,
+        contactEmail,
+        version,
+        syncVersion,
+        sdkSource,
+    };
+}
+function validateEmail(value) {
+    if (value === "") {
+        return undefined;
+    }
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+        return `"${value}" does not look like an email address`;
+    }
+    return undefined;
+}
+async function selectLibraries(question, libraries) {
+    const items = libraries.map((lib) => ({
+        label: lib.name_id,
+        hint: `${lib.name}${lib.summary !== "" ? ` - ${truncate(lib.summary, 70)}` : ""} (id ${lib.id})`,
+    }));
+    const picked = await (0, prompt_1.multiSelect)(question, items);
+    return libraries.filter((_, i) => picked[i]).map((lib) => ({ name: lib.name_id, id: lib.id }));
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}…`;
+}
+function dependenciesFromFlag(value, flag) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        return (0, libraries_1.parseDependencies)(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const hint = error instanceof errors_1.CliError ? error.hint : undefined;
+        throw new errors_1.CliError(`${flag}: ${message}`, hint);
+    }
+}
+function isInstalledFromRegistry() {
+    return (0, project_1.sdkRoot)().split(path.sep).includes("node_modules");
+}
+const SDK_PACKAGES = ["rs3-api-core", "rs3-api-extended", "rs3-api-ts"];
+/** Follows the workspace and npm link symlinks to the real folder. */
+function packageRoot(name) {
+    if (name === "rs3-api-ts") {
+        return (0, project_1.sdkRoot)();
+    }
+    return fs.realpathSync(path.dirname(require.resolve(`${name}/package.json`)));
+}
+function sdkDependencies(answers, target) {
+    const out = {};
+    for (const name of SDK_PACKAGES) {
+        const root = packageRoot(name);
+        if (answers.sdkSource === "registry") {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+            out[name] = `^${pkg.version}`;
+        }
+        else {
+            out[name] = `file:${path.relative(target, root).split(path.sep).join("/")}`;
+        }
+    }
+    return out;
+}
+/** `"https://a.example/, backend=https://b.example/"` -> `{ api: ..., backend: ... }` */
+function parseUrls(input) {
+    const out = {};
+    let unnamed = 0;
+    for (const raw of input.split(",")) {
+        const entry = raw.trim();
+        if (entry === "") {
+            continue;
+        }
+        const eq = entry.indexOf("=");
+        let name;
+        let url;
+        if (eq > 0 && !/^[a-z][a-z0-9+.-]*:\/\//i.test(entry)) {
+            name = entry.slice(0, eq).trim();
+            url = entry.slice(eq + 1).trim();
+        }
+        else {
+            unnamed++;
+            name = unnamed === 1 ? "api" : `api${unnamed}`;
+            url = entry;
+        }
+        out[name] = url;
+    }
+    return out;
+}
+function validateUrls(input) {
+    const seen = new Set();
+    let unnamed = 0;
+    for (const raw of input.split(",")) {
+        const entry = raw.trim();
+        if (entry === "") {
+            continue;
+        }
+        const eq = entry.indexOf("=");
+        let name;
+        let url;
+        if (eq > 0 && !/^[a-z][a-z0-9+.-]*:\/\//i.test(entry)) {
+            name = entry.slice(0, eq).trim();
+            url = entry.slice(eq + 1).trim();
+            if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(name)) {
+                return `"${name}" is not a valid url name (letters, digits, _ and -)`;
+            }
+        }
+        else {
+            unnamed++;
+            name = unnamed === 1 ? "api" : `api${unnamed}`;
+            url = entry;
+        }
+        if (seen.has(name)) {
+            return `url name "${name}" is used twice`;
+        }
+        seen.add(name);
+        const error = validateUrl(url);
+        if (error !== undefined) {
+            return error;
+        }
+    }
+    if (seen.size === 0) {
+        return "enter at least one URL";
+    }
+    return undefined;
+}
+async function selectPermissions(question, names, preselected) {
+    const items = names.map((name) => {
+        const info = (0, permissions_1.findPermission)(name);
+        return { label: name, hint: info?.description };
+    });
+    const picked = await (0, prompt_1.multiSelect)(question, items, names.map((n) => preselected.includes(n)));
+    return names.filter((_, i) => picked[i]);
+}
+function validatePermissionList(list, flag) {
+    if (list === undefined) {
+        return;
+    }
+    for (const name of list) {
+        if ((0, permissions_1.findPermission)(name) === undefined) {
+            throw new errors_1.CliError(`${flag}: "${name}" is not a permission the client knows`, [
+                `valid permissions: ${(0, permissions_1.permissionNames)().join(", ")}`,
+                "the client refuses to load a plugin that asks for anything else",
+            ]);
+        }
+    }
+}
+async function resolveText(interactive, given, question, fallback, validate, hint) {
+    if (given !== undefined) {
+        const error = validate(given);
+        if (error !== undefined) {
+            throw new errors_1.CliError(error, hint);
+        }
+        return given;
+    }
+    if (!interactive) {
+        if (fallback === undefined) {
+            const label = question.replace(/\s*\(.*\)\s*$/, "").toLowerCase();
+            throw new errors_1.CliError(`${label} is required`, hint ?? ["pass it on the command line, or run without --yes to be asked"]);
+        }
+        return fallback;
+    }
+    return (0, prompt_1.text)(question, fallback, validate);
+}
+async function resolveBoolean(interactive, given, question, fallback) {
+    if (given !== undefined) {
+        return given;
+    }
+    if (!interactive) {
+        return fallback;
+    }
+    return (0, prompt_1.confirm)(question, fallback);
+}
+function validateName(value) {
+    if (!NAME_PATTERN.test(value)) {
+        return `"${value}" must be lowercase letters, digits and dashes, starting with a letter or digit`;
+    }
+    return undefined;
+}
+const NAME_HINT = [
+    "it becomes the folder, the npm package name and the plugin id, so: my-plugin",
+    "pass it as an argument: rs3-plugin init my-plugin",
+];
+function validateVersion(value) {
+    if (!VERSION_PATTERN.test(value)) {
+        return `"${value}" must be three numbers separated by dots, like 0.1.0`;
+    }
+    return undefined;
+}
+function validateUrl(value) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            return "the URL must start with http:// or https://";
+        }
+        return undefined;
+    }
+    catch {
+        return `"${value}" is not a valid URL`;
+    }
+}
+function packageJson(answers, sdkDependencies) {
+    return {
+        name: answers.name,
+        version: answers.version,
+        private: true,
+        scripts: {
+            build: "rs3-plugin build",
+            dev: "rs3-plugin dev",
+        },
+        rs3: {
+            syncVersion: answers.syncVersion,
+        },
+        devDependencies: sdkDependencies,
+    };
+}
+function pluginJson(answers) {
+    const manifest = {
+        name: answers.name,
+        version: answers.version,
+        dependencies: {},
+        requiredDependencies: (0, libraries_1.toManifestDependencies)(answers.requiredDependencies),
+        optionalDependencies: (0, libraries_1.toManifestDependencies)(answers.optionalDependencies),
+        requiredPermissions: answers.requiredPermissions,
+        optionalPermissions: answers.optionalPermissions,
+        urls: answers.urls !== undefined ? parseUrls(answers.urls) : {},
+        resources: {},
+        hasSettingsIcon: answers.settingsIcon,
+        hasRibbonIcon: answers.ribbonIcon,
+    };
+    if (answers.contactEmail !== undefined) {
+        manifest.contactEmailAddress = answers.contactEmail;
+    }
+    return manifest;
+}
+function copyTemplates(templates, answers, write) {
+    const replacements = {
+        __NAME__: answers.name,
+    };
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const from = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(from);
+                continue;
+            }
+            // Templates npm or git would act on inside this package are stored with a leading
+            // underscore: _tsconfig.json -> tsconfig.json, _gitignore -> .gitignore.
+            const relativeDir = path.dirname(path.relative(templates, from));
+            const destName = RENAMES[entry.name] ?? (entry.name.startsWith("_") ? entry.name.slice(1) : entry.name);
+            let content = fs.readFileSync(from, "utf8");
+            for (const [token, value] of Object.entries(replacements)) {
+                content = content.split(token).join(value);
+            }
+            write(path.join(relativeDir, destName), content);
+        }
+    };
+    walk(templates);
+}