@konce-pt/ui 0.7.9 → 0.7.11

package/dist/commands/add.js

@@ -9,13 +9,47 @@ export async function addCommand(args) {
     if (requested.length === 0)
         throw new UserError('Podaj nazwę bloku: add <nazwa...>');
     const { path: configPath, config } = requireConfig(process.cwd());
-    const projectRoot = path.dirname(configPath);
-    const base = flag(args, 'registry') ?? config.registry;
-    const overwrite = hasFlag(args, 'overwrite');
+    const ctx = {
+        base: flag(args, 'registry') ?? config.registry,
+        config,
+        projectRoot: path.dirname(configPath),
+        targetDirRel: flag(args, 'path') ?? config.blocksDir,
+        overwrite: hasFlag(args, 'overwrite'),
+    };
     const dryRun = hasFlag(args, 'dry-run');
-    const targetDirRel = flag(args, 'path') ?? config.blocksDir;
-    const index = await loadIndex(base);
+    const index = await loadIndex(ctx.base);
     // 1) Rozwiąż zależności registry rekurencyjnie (kolejność zależnościowa, wykryj cykle).
+    const order = resolveOrder(requested, index);
+    // 2) Pomiń już zainstalowane (chyba że --overwrite).
+    const toInstall = order.filter((name) => ctx.overwrite || !config.installedBlocks[name]);
+    logAlreadyInstalled(order, ctx);
+    if (toInstall.length === 0) {
+        log.info('Nic do zrobienia.');
+        return;
+    }
+    // 3) Wczytaj definicje, sprawdź zależności npm.
+    const metas = new Map();
+    for (const name of toInstall)
+        metas.set(name, await loadBlockMeta(ctx.base, name));
+    checkNpmDependencies(metas, ctx.projectRoot);
+    // 4) Pobierz WSZYSTKIE pliki i zaplanuj zapis (instalacja atomowa — nic nie zapisujemy wcześniej).
+    const plan = await planWrites(toInstall, metas, ctx);
+    // 5) Zapis (albo raport dry-run).
+    if (dryRun) {
+        log.info('— dry-run: żadnych zapisów —');
+        for (const p of plan)
+            log.step(`${labelFor(p.action)}  ${p.target}`);
+    }
+    else {
+        applyPlan(plan, ctx.projectRoot);
+        markInstalled(config, toInstall, index.libraryVersion);
+        writeConfig(configPath, config);
+    }
+    printSummary(toInstall, metas, dryRun);
+}
+// — pomocnicze —
+/** Kolejność instalacji: zależności registry przed blokiem, który ich potrzebuje. Wykrywa cykle. */
+function resolveOrder(requested, index) {
     const order = [];
     const done = new Set();
     const stack = new Set();
@@ -36,57 +70,49 @@ export async function addCommand(args) {
     };
     for (const name of requested)
         visit(name);
-    // 2) Pomiń już zainstalowane (chyba że --overwrite).
-    const toInstall = order.filter((name) => overwrite || !config.installedBlocks[name]);
-    const skippedInstalled = order.filter((name) => !overwrite && config.installedBlocks[name]);
-    for (const name of skippedInstalled)
-        log.step(`${name} — już zainstalowany (pomijam; --overwrite by nadpisać)`);
-    if (toInstall.length === 0) {
-        log.info('Nic do zrobienia.');
+    return order;
+}
+function logAlreadyInstalled(order, ctx) {
+    if (ctx.overwrite)
         return;
+    for (const name of order) {
+        if (ctx.config.installedBlocks[name]) {
+            log.step(`${name} — już zainstalowany (pomijam; --overwrite by nadpisać)`);
+        }
     }
-    // 3) Wczytaj definicje, sprawdź zależności npm.
-    const metas = new Map();
-    for (const name of toInstall)
-        metas.set(name, await loadBlockMeta(base, name));
-    checkNpmDependencies(metas, projectRoot);
-    // 4) Pobierz WSZYSTKIE pliki i zaplanuj zapis (instalacja atomowa — nic nie zapisujemy wcześniej).
+}
+/** Pobiera pliki wszystkich bloków i planuje zapis — bez dotykania dysku. */
+async function planWrites(toInstall, metas, ctx) {
     const plan = [];
     for (const name of toInstall) {
         const meta = metas.get(name);
         for (const file of meta.files) {
-            const raw = await loadBlockFile(base, name, file.path);
-            const content = rewriteImports(raw, config);
-            const absolute = path.resolve(projectRoot, targetDirRel, name, file.path);
-            plan.push(planWrite(name, absolute, content, projectRoot, overwrite));
+            const raw = await loadBlockFile(ctx.base, name, file.path);
+            const content = rewriteImports(raw, ctx.config);
+            const absolute = path.resolve(ctx.projectRoot, ctx.targetDirRel, name, file.path);
+            plan.push(planWrite(name, absolute, content, ctx.projectRoot, ctx.overwrite));
         }
     }
-    // 5) Zapis (albo raport dry-run).
-    if (dryRun) {
-        log.info('— dry-run: żadnych zapisów —');
-        for (const p of plan)
-            log.step(`${labelFor(p.action)}  ${p.target}`);
-    }
-    else {
-        for (const p of plan) {
-            if (p.action === 'skip-identical') {
-                log.step(`bez zmian  ${p.target}`);
-                continue;
-            }
-            const dest = p.action === 'conflict-new' ? `${p.absolute}.new` : p.absolute;
-            mkdirSync(path.dirname(dest), { recursive: true });
-            writeFileSync(dest, p.content);
-            log.step(`${labelFor(p.action)}  ${path.relative(projectRoot, dest)}`);
-        }
-        const now = new Date().toISOString().slice(0, 10);
-        for (const name of toInstall) {
-            config.installedBlocks[name] = { version: index.libraryVersion, installedAt: now };
+    return plan;
+}
+function applyPlan(plan, projectRoot) {
+    for (const p of plan) {
+        if (p.action === 'skip-identical') {
+            log.step(`bez zmian  ${p.target}`);
+            continue;
         }
-        writeConfig(configPath, config);
+        const dest = p.action === 'conflict-new' ? `${p.absolute}.new` : p.absolute;
+        mkdirSync(path.dirname(dest), { recursive: true });
+        writeFileSync(dest, p.content);
+        log.step(`${labelFor(p.action)}  ${path.relative(projectRoot, dest)}`);
+    }
+}
+function markInstalled(config, installed, libraryVersion) {
+    const now = new Date().toISOString().slice(0, 10);
+    for (const name of installed) {
+        config.installedBlocks[name] = { version: libraryVersion, installedAt: now };
     }
-    printSummary(toInstall, metas, dryRun);
 }
-// — pomocnicze —
 function planWrite(block, absolute, content, projectRoot, overwrite) {
     const target = path.relative(projectRoot, absolute);
     if (!existsSync(absolute))
@@ -110,7 +136,7 @@ function labelFor(action) {
 function rewriteImports(content, config) {
     let out = content.replaceAll('@/', `${config.alias}/`);
     if (config.prefix !== 'kpt') {
-        out = out.replace(/(?<![-\w])kpt-/g, `${config.prefix}-`);
+        out = out.replaceAll(/(?<![-\w])kpt-/g, `${config.prefix}-`);
     }
     return out;
 }
@@ -123,60 +149,80 @@ function rewriteImports(content, config) {
  * inaczej niż npm, byłby gorszy od ostrzeżenia.
  */
 function checkNpmDependencies(metas, projectRoot) {
-    const pkgPath = path.join(projectRoot, 'package.json');
-    const installed = {};
-    if (existsSync(pkgPath)) {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-        Object.assign(installed, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
-    }
+    const installed = readInstalledDeps(projectRoot);
     const missing = new Map();
     // Set, bo kilka bloków deklaruje zwykle ten sam peer (@angular/core) — bez tego
     // to samo ostrzeżenie poszłoby raz na blok.
     const peerNotes = new Set();
-    for (const meta of metas.values()) {
-        for (const [kind, deps] of [
-            ['npm', meta.dependencies?.npm ?? {}],
-            ['peer', meta.dependencies?.peer ?? {}],
-        ]) {
-            for (const [name, range] of Object.entries(deps)) {
-                const have = installed[name];
-                if (!have) {
-                    if (kind === 'npm')
-                        missing.set(name, range);
-                    else
-                        peerNotes.add(`${name} (peer) — brak w projekcie, blok wymaga ${range}`);
-                    continue;
-                }
-                // Specyfikatory bez konkretnej wersji (workspace:*, *, latest, git/file:) — nie oceniamy.
-                if (!/\d/.test(have))
-                    continue;
-                if (satisfies(have, range))
-                    continue;
-                if (kind === 'npm') {
-                    throw new UserError(`Zależność ${name} jest w wersji ${have}, blok wymaga ${range}. ` +
-                        `Zaktualizuj ją samodzielnie i uruchom ponownie.`);
-                }
-                peerNotes.add(`${name} (peer) jest w wersji ${have}, blok wymaga ${range}`);
+    for (const { kind, name, range } of declaredDependencies(metas)) {
+        const have = installed[name];
+        const verdict = inspectDependency(range, have);
+        if (verdict === 'ok')
+            continue;
+        if (kind === 'npm') {
+            if (verdict === 'missing')
+                missing.set(name, range);
+            else {
+                throw new UserError(`Zależność ${name} jest w wersji ${have}, blok wymaga ${range}. ` +
+                    `Zaktualizuj ją samodzielnie i uruchom ponownie.`);
             }
+            continue;
         }
+        peerNotes.add(verdict === 'missing'
+            ? `${name} (peer) — brak w projekcie, blok wymaga ${range}`
+            : `${name} (peer) jest w wersji ${have}, blok wymaga ${range}`);
     }
-    if (missing.size > 0) {
-        // Do instalacji podajemy same nazwy — zakres bywa złożony (">=0.6.0 <1.0.0")
-        // i wklejony do shella by się rozpadł. Wymagania pokazujemy osobno.
-        log.warn(`Brakujące zależności npm — zainstaluj je: ${[...missing.keys()].join(' ')}`);
-        for (const [name, range] of missing)
-            log.step(`${name} wymaga ${range}`);
-    }
+    reportMissing(missing);
     for (const note of peerNotes)
         log.warn(note);
 }
+/** `dependencies` + `devDependencies` z package.json projektu (devDeps wygrywają). */
+function readInstalledDeps(projectRoot) {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!existsSync(pkgPath))
+        return {};
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    // Rozwinięcie `undefined` w literale obiektu jest legalne i nic nie wnosi — bez `?? {}`.
+    return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+/** Płaska lista zależności zadeklarowanych przez wszystkie instalowane bloki. */
+function* declaredDependencies(metas) {
+    for (const meta of metas.values()) {
+        yield* dependenciesOfKind('npm', meta.dependencies?.npm);
+        yield* dependenciesOfKind('peer', meta.dependencies?.peer);
+    }
+}
+function* dependenciesOfKind(kind, deps) {
+    if (!deps)
+        return;
+    for (const [name, range] of Object.entries(deps))
+        yield { kind, name, range };
+}
+/** Werdykt dla jednej zależności — bez rozróżnienia na npm/peer, to robi wołający. */
+function inspectDependency(range, have) {
+    if (!have)
+        return 'missing';
+    // Specyfikatory bez konkretnej wersji (workspace:*, *, latest, git/file:) — nie oceniamy.
+    if (!/\d/.test(have))
+        return 'ok';
+    return satisfies(have, range) ? 'ok' : 'mismatch';
+}
+function reportMissing(missing) {
+    if (missing.size === 0)
+        return;
+    // Do instalacji podajemy same nazwy — zakres bywa złożony (">=0.6.0 <1.0.0")
+    // i wklejony do shella by się rozpadł. Wymagania pokazujemy osobno.
+    log.warn(`Brakujące zależności npm — zainstaluj je: ${[...missing.keys()].join(' ')}`);
+    for (const [name, range] of missing)
+        log.step(`${name} wymaga ${range}`);
+}
 function printSummary(installed, metas, dryRun) {
     log.info(`\n${dryRun ? 'Zainstalowałbym' : 'Zainstalowano'}: ${installed.join(', ')}`);
     for (const name of installed) {
         const meta = metas.get(name);
         if (meta.usage) {
             log.info(`\n${name}:`);
-            log.step(meta.usage.replace(/\n/g, '\n  '));
+            log.step(meta.usage.replaceAll('\n', '\n  '));
         }
         const ports = meta.api?.ports ?? [];
         for (const port of ports) {

package/dist/semver.js

@@ -31,7 +31,9 @@ function caretUpper([maj, min, patch]) {
 }
 /** Pojedynczy komparator. `null` = nie rozumiem tego kształtu. */
 function satisfiesOne(version, comparator) {
-    const m = /^(>=|<=|>|<|=|\^|~|)\s*(.+)$/.exec(comparator.trim());
+    // `\S` po `\s*` jest istotne: `\s*(.+)` pozwalałoby dopasować spację obu członom,
+    // co daje wykładniczy nawrót przy patologicznym wejściu.
+    const m = /^(>=|<=|>|<|=|\^|~|)\s*(\S.*)$/.exec(comparator.trim());
     if (!m)
         return null;
     const [, op, rest] = m;
@@ -64,7 +66,7 @@ export function satisfies(version, range) {
         if (comparators.length === 0)
             continue;
         const results = comparators.map((c) => satisfiesOne(parsed, c));
-        if (results.some((r) => r === null))
+        if (results.includes(null))
             return true; // nieznany kształt — nie oceniamy
         if (results.every(Boolean))
             return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konce-pt/ui",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "CLI Koncept UI — instaluje bloki (copy-paste) do projektu Angular: init, add, list.",
   "license": "MIT",
   "author": "konce.pt",