create-pkgbld 1.8.2 → 2.0.1

package/src/tui.js

@@ -0,0 +1,167 @@
+import prompts from 'prompts';
+
+import { blue, gray, green, red } from '@niceties/ansi';
+
+/**
+ * @typedef {import('prompts').PromptObject} PromptObject
+ * @typedef {import('./types.js').Option} Option
+ * @typedef {import('./types.js').OptionsValue} OptionsValue
+ * @typedef {{
+ *   operation: import('./package-operations.js').PreparedPackageOperation,
+ *   answers: OptionsValue
+ * }} PendingPackageOperation
+ */
+
+export const done = Symbol('done');
+const PACKAGE_PREFIX = '__package__:';
+
+/**
+ * @param {string} value
+ * @param {number} [indent]
+ * @param {number} [offset]
+ */
+export function pad16plus(value, indent = 4, offset = 3) {
+    return value + ''.padEnd(offset - Math.floor((value.length + indent) / 8), '\t');
+}
+
+/**
+ * Convert an Option leaf into a prompts() configuration.
+ *
+ * @param {Option} option
+ * @param {OptionsValue} answers
+ * @returns {PromptObject}
+ */
+export function getPromptOption(option, answers) {
+    const value = answers[option.field];
+    const initialValue = value ?? option.initialValue;
+    const type = option.type ?? 'text';
+    /** @type {PromptObject} */
+    const promptOption = {
+        type,
+        name: option.field,
+        message: option.title,
+        initial: /** @type {any} */ (Array.isArray(initialValue) ? initialValue.join(',') : (initialValue ?? '')),
+    };
+    if (type === 'multiselect') {
+        promptOption.choices =
+            'list' in option
+                ? option.list.map((/** @type {string} */ item) => ({
+                      title: item,
+                      value: item,
+                      selected: Array.isArray(initialValue) && initialValue.includes(item),
+                  }))
+                : [];
+    }
+    if (type === 'select') {
+        promptOption.choices =
+            'list' in option
+                ? option.list.map((/** @type {string} */ item) => ({
+                      title: item,
+                      value: item,
+                  }))
+                : [];
+        promptOption.initial = /** @type {import('prompts').Choice[]} */ (promptOption.choices).findIndex(
+            (/** @type {import('prompts').Choice} */ item) => item.value === promptOption.initial
+        );
+    }
+    return promptOption;
+}
+
+/**
+ * @param {import('./package-operations.js').PackageView} item
+ * @param {PendingPackageOperation | undefined} pending
+ */
+function renderPackageLabel(item, pending) {
+    const left = pad16plus(item.name);
+    if (pending) return `${left}${blue(`[Pending ${pending.operation.effect}]`)}`;
+    if (item.state === 'unavailable') return `${left}${red('[Unavailable]')} ${gray(item.error ?? '')}`;
+    if (item.state === 'available') return `${left}${gray('[Available]')}`;
+    if (item.state === 'applied') return `${left}${blue('[Applied]')}`;
+    if (item.state === 'installed-managed') return `${left}${green('[Installed, managed]')}`;
+    return `${left}${blue('[Installed, unmanaged]')}`;
+}
+
+/**
+ * Collect package targets and their answers. Project changes remain unstaged
+ * until the caller stages the returned operations.
+ *
+ * @param {{ packageOperations: Awaited<ReturnType<import('./package-operations.js').openPackageOperations>> }} params
+ * @returns {Promise<PendingPackageOperation[]>}
+ */
+export async function runInteractiveLoop({ packageOperations }) {
+    let cancelled = false;
+    function onCancel() {
+        cancelled = true;
+    }
+    /** @type {Map<string, PendingPackageOperation>} */
+    const pending = new Map();
+
+    for (;;) {
+        const packageAction = await prompts(
+            {
+                type: 'select',
+                name: 'value',
+                message: 'Select a PKG BLD package, Done to execute, Escape to cancel',
+                choices: [
+                    { title: green('Done'), value: /** @type {any} */ (done) },
+                    ...packageOperations.inventory.map(item => ({
+                        title: renderPackageLabel(item, pending.get(item.id)),
+                        value: `${PACKAGE_PREFIX}${item.id}`,
+                    })),
+                ],
+                initial: 0,
+            },
+            { onCancel }
+        );
+        if (cancelled) throw new Error('cancelled');
+        if (packageAction.value === done) return [...pending.values()];
+
+        if (typeof packageAction.value !== 'string' || !packageAction.value.startsWith(PACKAGE_PREFIX)) continue;
+        const id = packageAction.value.slice(PACKAGE_PREFIX.length);
+        const item = packageOperations.inventory.find(candidate => candidate.id === id);
+        if (!item) continue;
+        if (pending.delete(id)) continue;
+        if (item.state === 'unavailable') {
+            console.log(red(`Package "${item.name}" is unavailable: ${item.error ?? 'not resolvable'}`));
+            continue;
+        }
+
+        /** @type {import('./package-operations.js').PackageTarget} */
+        let target;
+        if (item.state === 'installed-unmanaged') {
+            const action = await prompts(
+                {
+                    type: 'select',
+                    name: 'value',
+                    message: `Manage ${item.name}`,
+                    choices: [
+                        { title: 'Adopt', value: 'managed' },
+                        { title: 'Remove', value: 'absent' },
+                        { title: 'Cancel', value: null },
+                    ],
+                },
+                { onCancel }
+            );
+            if (cancelled) throw new Error('cancelled');
+            if (action.value === null || action.value === undefined) continue;
+            target = action.value;
+        } else {
+            target = item.state === 'installed-managed' ? 'absent' : 'managed';
+        }
+
+        try {
+            const operation = await packageOperations.prepare({ package: id, target });
+            /** @type {OptionsValue} */
+            const answers = {};
+            for (const question of operation.questions) {
+                const answer = await prompts(getPromptOption(question, answers), { onCancel });
+                if (cancelled) throw new Error('cancelled');
+                answers[question.field] = answer[question.field];
+            }
+            pending.set(id, { operation, answers });
+        } catch (/** @type {any} */ error) {
+            if (error.message === 'cancelled') throw error;
+            console.log(red(`Package "${item.name}" is unavailable: ${error.message ?? String(error)}`));
+        }
+    }
+}

package/src/types.js

@@ -0,0 +1,28 @@
+/** @typedef {import('pkgbld/options').PackageJson} PackageJson */
+
+/**
+ * @typedef {{
+ *   title: string;
+ *   field: string;
+ *   initialValue?: string | string[] | boolean;
+ * } & (
+ *   | { type?: undefined | 'toggle' | 'list' | 'text' }
+ *   | { type: 'multiselect' | 'select'; list: string[] }
+ * )} Option
+ */
+
+/**
+ * @typedef {{
+ *   readme: string;
+ *   pkg: PackageJson;
+ *   mode: 'create' | 'update';
+ * }} PkgInfo
+ */
+
+/**
+ * @typedef {{
+ *   [key: string]: undefined | null | number | boolean | string | string[] | OptionsValue;
+ * }} OptionsValue
+ */
+
+export {};

package/src/update-engine.js

@@ -0,0 +1,196 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+const ABSENT = Symbol('absent');
+
+/**
+ * Apply target-version update behavior or guarded declarative reconciliation.
+ * @param {{
+ *   previous: import('./registry.js').Extension,
+ *   target: import('./registry.js').Extension,
+ *   tree: import('./tree.js').Tree,
+ *   fromVersion: string,
+ *   toVersion: string,
+ *   options?: import('./types.js').OptionsValue,
+ *   exclude?: string[],
+ *   reportConflict(conflict: { resource: string, message: string, expected?: unknown, current?: unknown, proposed?: unknown }): void
+ * }} params
+ */
+export async function runExtensionUpdate({ previous, target, tree, fromVersion, toVersion, options = {}, exclude = [], reportConflict }) {
+    const reconcileDeclarative = (/** @type {{ exclude?: string[] }} */ reconcileOptions = {}) => {
+        if (!isDeclarative(previous.setup) || !isDeclarative(target.setup)) {
+            throw new Error('Declarative reconciliation requires declarative setup in both package versions');
+        }
+        reconcileSetups(previous, target, tree, reportConflict, [...exclude, ...(reconcileOptions.exclude ?? [])]);
+    };
+
+    if (typeof target.update === 'function') {
+        tree.setExtensionBase(target.__baseDir ?? null);
+        try {
+            await target.update(tree, Object.freeze({ fromVersion, toVersion, reconcileDeclarative, reportConflict }), options);
+        } finally {
+            tree.setExtensionBase(null);
+        }
+        return;
+    }
+
+    if (!isDeclarative(previous.setup) || !isDeclarative(target.setup)) {
+        throw new Error(`Update from ${fromVersion} to ${toVersion} is unsupported: the target has no update function`);
+    }
+    reconcileDeclarative();
+}
+
+/** @param {unknown} setup */
+function isDeclarative(setup) {
+    return Boolean(setup && typeof setup === 'object' && !Array.isArray(setup));
+}
+
+/**
+ * @param {import('./registry.js').Extension} previous
+ * @param {import('./registry.js').Extension} target
+ * @param {import('./tree.js').Tree} tree
+ * @param {(conflict: any) => void} reportConflict
+ * @param {string[]} excluded
+ */
+function reconcileSetups(previous, target, tree, reportConflict, excluded) {
+    const oldResources = collectResources(/** @type {import('./registry.js').SetupDeclarative} */ (previous.setup), previous);
+    const newResources = collectResources(/** @type {import('./registry.js').SetupDeclarative} */ (target.setup), target);
+    const excludedSet = new Set(excluded);
+    const keys = new Set([...oldResources.keys(), ...newResources.keys()]);
+
+    for (const key of [...keys].sort()) {
+        if (excludedSet.has(key)) continue;
+        const oldResource = oldResources.get(key);
+        const newResource = newResources.get(key);
+        const resource = newResource ?? oldResource;
+        if (!resource) continue;
+        const oldValue = oldResource?.value ?? ABSENT;
+        const newValue = newResource?.value ?? ABSENT;
+        const currentValue = readCurrent(resource, tree);
+
+        if (sameValue(currentValue, oldValue, resource) || sameValue(currentValue, newValue, resource)) {
+            if (!sameValue(currentValue, newValue, resource)) applyValue(resource, newValue, tree);
+            continue;
+        }
+        if (sameValue(oldValue, newValue, resource)) continue;
+
+        reportConflict({
+            resource: key,
+            expected: externalValue(oldValue),
+            current: externalValue(currentValue),
+            proposed: externalValue(newValue),
+            message: `Resource "${displayResource(resource)}" was changed after the previous package version was applied`,
+        });
+        applyValue(resource, newValue, tree);
+    }
+}
+
+/** @param {import('./registry.js').SetupDeclarative} setup @param {import('./registry.js').Extension} extension */
+function collectResources(setup, extension) {
+    /** @type {Map<string, any>} */
+    const resources = new Map();
+    for (const [name, value] of Object.entries(setup.dependencies ?? {})) {
+        resources.set(`dependency:dependencies:${name}`, { kind: 'dependency', field: 'dependencies', name, value });
+    }
+    for (const [name, value] of Object.entries(setup.devDependencies ?? {})) {
+        resources.set(`dependency:devDependencies:${name}`, { kind: 'dependency', field: 'devDependencies', name, value });
+    }
+    for (const [name, value] of Object.entries(setup.scripts ?? {})) {
+        resources.set(`script:${name}`, { kind: 'script', name, value });
+    }
+    for (const [target, source] of Object.entries(setup.files ?? {})) {
+        const value = source.startsWith('inline:')
+            ? source.slice('inline:'.length)
+            : readFileSync(resolveExtensionFile(extension, source), 'utf8');
+        resources.set(`file:${target}`, { kind: 'file', path: target, value });
+    }
+    for (const [name, value] of Object.entries(setup.packageJson ?? {})) {
+        resources.set(`package-json:${name}`, { kind: 'package-json', name, value });
+    }
+    return resources;
+}
+
+/** @param {import('./registry.js').Extension} extension @param {string} relativePath */
+function resolveExtensionFile(extension, relativePath) {
+    if (!extension.__baseDir) throw new Error(`Cannot resolve extension file "${relativePath}": package base is unavailable`);
+    return path.resolve(extension.__baseDir, relativePath);
+}
+
+/** @param {any} resource @param {import('./tree.js').Tree} tree */
+function readCurrent(resource, tree) {
+    if (resource.kind === 'file') return tree.read(resource.path) ?? ABSENT;
+    const pkg = tree.readJson('package.json') ?? {};
+    if (resource.kind === 'dependency') return pkg[resource.field]?.[resource.name] ?? ABSENT;
+    if (resource.kind === 'script') return pkg.scripts?.[resource.name] ?? ABSENT;
+    return pkg[resource.name] ?? ABSENT;
+}
+
+/** @param {any} resource @param {unknown} value @param {import('./tree.js').Tree} tree */
+function applyValue(resource, value, tree) {
+    if (resource.kind === 'file') {
+        if (value === ABSENT) tree.delete(resource.path);
+        else tree.write(resource.path, /** @type {string} */ (value));
+        return;
+    }
+    tree.updateJson('package.json', pkg => {
+        const container = resource.kind === 'dependency' ? resource.field : resource.kind === 'script' ? 'scripts' : null;
+        if (container) {
+            if (value === ABSENT) {
+                if (pkg[container]) {
+                    delete pkg[container][resource.name];
+                    if (Object.keys(pkg[container]).length === 0) delete pkg[container];
+                }
+            } else {
+                pkg[container] ??= {};
+                pkg[container][resource.name] = value;
+            }
+        } else if (value === ABSENT) {
+            delete pkg[resource.name];
+        } else {
+            pkg[resource.name] = value;
+        }
+        return pkg;
+    });
+}
+
+/** @param {unknown} left @param {unknown} right @param {any} resource */
+function sameValue(left, right, resource) {
+    if (left === ABSENT || right === ABSENT) return left === right;
+    if (resource.kind === 'file' && resource.path.endsWith('.json')) {
+        try {
+            return fingerprint(JSON.parse(/** @type {string} */ (left))) === fingerprint(JSON.parse(/** @type {string} */ (right)));
+        } catch {
+            return left === right;
+        }
+    }
+    return fingerprint(left) === fingerprint(right);
+}
+
+/** @param {unknown} value */
+function fingerprint(value) {
+    return JSON.stringify(canonicalize(value));
+}
+
+/** @param {unknown} value @returns {unknown} */
+function canonicalize(value) {
+    if (Array.isArray(value)) return value.map(canonicalize);
+    if (!value || typeof value !== 'object') return value;
+    return Object.fromEntries(
+        Object.entries(/** @type {Record<string, unknown>} */ (value))
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => [key, canonicalize(item)])
+    );
+}
+
+/** @param {unknown} value */
+function externalValue(value) {
+    return value === ABSENT ? undefined : value;
+}
+
+/** @param {any} resource */
+function displayResource(resource) {
+    if (resource.kind === 'file') return resource.path;
+    if (resource.kind === 'dependency') return `${resource.field}.${resource.name}`;
+    if (resource.kind === 'script') return `scripts.${resource.name}`;
+    return `package.json:${resource.name}`;
+}

package/CHANGELOG.md

@@ -1,206 +0,0 @@
-# Changelog
-
-## 1.8.2
-
-### Patch Changes
-
-- 23056c6: update packages, fix lint errors
-
-## 1.8.1
-
-### Patch Changes
-
-- 995cf22: fix \_\_dirname not defined
-
-## 1.8.0
-
-### Minor Changes
-
-- 5145047: - node 20 is minimal engine now
-  - sort exports according to package type so `require` is higher than `import` for type === "module" and lower for type === "commonjs"
-  - wait for tsconfig being processed before processing the package
-  - do not write declarations if they are not enabled in tsconfig
-  - remove 'packageManager' from package.json on prune
-  - consume jsconfig.json
-  - do not write exports option
-  - handle directories.bin in package.json
-  - use es modules where possible
-
-## 1.7.3
-
-### Patch Changes
-
-- 0091f32: added support for typesVersions
-
-## 1.7.2
-
-### Patch Changes
-
-- d942874: use prune
-
-## 1.7.1
-
-### Patch Changes
-
-- added prepack to self
-
-## 1.7.0
-
-### Minor Changes
-
-- 633fa9f: fixed command line parameters update
-  added simplified status per option in main menu
-
-## 1.6.0
-
-### Minor Changes
-
-- 0438287: use shared internal library to parse options / package.json
-
-## 1.5.0
-
-### Minor Changes
-
-- fdcf99f: extended include-externals to specify individual externals
-
-## 1.4.6
-
-### Patch Changes
-
-- 9ce9955: added non-standart unpkg to package fields list
-
-## 1.4.5
-
-### Patch Changes
-
-- cc06bb8: make quiet really quiet
-- 5f6883e: add newline to package.json same way as pkgbld does
-- b203bae: stricter package.json parsing
-
-## 1.4.4
-
-### Patch Changes
-
-- 5950c96: added more fields for ordering
-
-## 1.4.3
-
-### Patch Changes
-
-- 5fac6a1: fix: handle author object
-
-## 1.4.2
-
-### Patch Changes
-
-- 54ce107: fix typo
-
-## 1.4.1
-
-### Patch Changes
-
-- ea0a7cb: remove redundunt debug console.log()
-- 1e0d5a4: update packages to match new structure
-- fd406cc: added missing `readme` field
-
-## 1.4.0
-
-### Minor Changes
-
-- 1cf3eb4: more advanced implementation to allow create / update more complex packages (still some features missing)
-
-## 1.3.0
-
-### Minor Changes
-
-- 3daff62: Added a menu to quickly edit package
-
-## 1.2.0
-
-### Minor Changes
-
-- b4556f5: simplified package so it provides bare minimum of functionality, fixed issue running in current / another directory, added automatic directory creation
-
-## 1.1.10
-
-### Patch Changes
-
-- 86c8d88: updated processing logic of default, module and types fields in package.json
-
-## 1.1.9
-
-### Patch Changes
-
-- 74a7f67: fix small mistakes in documentation
-
-## 1.1.8
-
-### Patch Changes
-
-- 1e29b8e: Fixed path to executable file in package.json
-
-## 1.1.7
-
-### Patch Changes
-
-- fc6c99a: Updated documentation and links
-
-## 1.1.6
-
-### Patch Changes
-
-- 03f2a71: Updated dependencies
-
-## 1.1.5
-
-### Patch Changes
-
-- 85c2ae6: When creating subpackage, assume that subpackage should be created in subdirectory if package name (cli argument) is not provided
-
-## [1.1.4](https://github.com/kshutkin/create-pkgbld/compare/v1.1.3...v1.1.4) (2022-11-01)
-
-### Bug Fixes
-
-- upgrade minimist from 1.2.6 to 1.2.7 ([#3](https://github.com/kshutkin/create-pkgbld/issues/3)) ([c24c8e3](https://github.com/kshutkin/create-pkgbld/commit/c24c8e3a838d409f980acf90142676312b207860))
-
-## [1.1.3](https://github.com/kshutkin/create-pkgbld/compare/v1.1.2...v1.1.3) (2022-03-23)
-
-### Bug Fixes
-
-- readme link ([6009ea8](https://github.com/kshutkin/create-pkgbld/commit/6009ea82fe06af9d939c5dd4747f08a94955b3d4))
-
-## [1.1.2](https://github.com/kshutkin/create-pkgbld/compare/v1.1.1...v1.1.2) (2022-03-23)
-
-### Bug Fixes
-
-- package.json & package-lock.json to reduce vulnerabilities ([#2](https://github.com/kshutkin/create-pkgbld/issues/2)) ([5d72496](https://github.com/kshutkin/create-pkgbld/commit/5d724967f1e1a4b33d24d197b99e15a7a244e301))
-
-## [1.1.1](https://github.com/kshutkin/create-pkgbld/compare/v1.1.0...v1.1.1) (2022-02-13)
-
-### Bug Fixes
-
-- use dirname ([6a5d8bb](https://github.com/kshutkin/create-pkgbld/commit/6a5d8bb23580f1639671e92b922b6df744299dc9))
-
-# [1.1.0](https://github.com/kshutkin/create-pkgbld/compare/v1.0.2...v1.1.0) (2022-02-13)
-
-### Features
-
-- display version on start ([c7c7051](https://github.com/kshutkin/create-pkgbld/commit/c7c7051bf4e4fe5f037891505de2addddf3b69ac))
-
-## [1.0.2](https://github.com/kshutkin/create-pkgbld/compare/v1.0.1...v1.0.2) (2022-02-08)
-
-### Bug Fixes
-
-- do not cache ([ced7de5](https://github.com/kshutkin/create-pkgbld/commit/ced7de5f3e092c4a91afb92368364387725738c9))
-
-## [1.0.1](https://github.com/kshutkin/create-pkgbld/compare/v1.0.0...v1.0.1) (2021-12-28)
-
-### Bug Fixes
-
-- undefined exception when run without arguments ([179e44a](https://github.com/kshutkin/create-pkgbld/commit/179e44a87fdfedb46b49053b2d7e245825188003))
-
-# 1.0.0 (2021-12-27)
-
-### Features
-
-- initial implementation ([#1](https://github.com/kshutkin/create-pkgbld/issues/1)) ([1fa648a](https://github.com/kshutkin/create-pkgbld/commit/1fa648ad2a06ffbb9116efb3501c68cd40de40ce))

package/eslint.config.mjs

@@ -1,42 +0,0 @@
-import typescriptEslint from '@typescript-eslint/eslint-plugin';
-import globals from 'globals';
-import tsParser from '@typescript-eslint/parser';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import js from '@eslint/js';
-import { FlatCompat } from '@eslint/eslintrc';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-    baseDirectory: __dirname,
-    recommendedConfig: js.configs.recommended,
-    allConfig: js.configs.all
-});
-
-export default [
-    ...compat.extends('eslint:recommended', 'plugin:@typescript-eslint/recommended'),
-    {
-        plugins: {
-            '@typescript-eslint': typescriptEslint,
-        },
-
-        languageOptions: {
-            globals: {
-                ...globals.browser,
-            },
-
-            parser: tsParser,
-            ecmaVersion: 13,
-            sourceType: 'module',
-        },
-
-        rules: {
-            '@typescript-eslint/no-non-null-assertion': ['off'],
-            indent: ['error', 4],
-            'linebreak-style': ['error', 'unix'],
-            quotes: ['error', 'single'],
-            semi: ['error', 'always'],
-        },
-    },
-];