@konce-pt/ui 0.6.0 → 0.6.1

package/dist/commands/add.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { requireConfig, writeConfig } from "../config.js";
 import { loadIndex, loadBlockMeta, loadBlockFile } from "../registry.js";
 import { flag, hasFlag, log, UserError } from "../util.js";
+import { satisfies } from "../semver.js";
 export async function addCommand(args) {
     const requested = args.positionals;
     if (requested.length === 0)
@@ -113,6 +114,14 @@ function rewriteImports(content, config) {
     }
     return out;
 }
+/**
+ * Weryfikuje zależności bloku względem package.json projektu.
+ *
+ * Rozróżnienie surowości jest celowe: `npm` to nasze paczki i zła wersja realnie
+ * psuje blok, więc przerywamy. `peer` to Angular i rxjs — ich wersję trzyma
+ * aplikacja, a twardy błąd na prerelease, którego prosty parser może odczytać
+ * inaczej niż npm, byłby gorszy od ostrzeżenia.
+ */
 function checkNpmDependencies(metas, projectRoot) {
     const pkgPath = path.join(projectRoot, 'package.json');
     const installed = {};
@@ -120,40 +129,46 @@ function checkNpmDependencies(metas, projectRoot) {
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
         Object.assign(installed, pkg.dependencies ?? {}, pkg.devDependencies ?? {});
     }
-    const missing = new Set();
+    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 [name, range] of Object.entries(meta.dependencies?.npm ?? {})) {
-            const have = installed[name];
-            if (!have) {
-                missing.add(`${name}@${range}`);
-                continue;
-            }
-            // Specyfikatory bez konkretnej wersji (workspace:*, *, latest, git/file:) — nie oceniamy.
-            if (!/\d/.test(have))
-                continue;
-            if (belowMinimum(have, range)) {
-                throw new UserError(`Zależność ${name} jest w wersji ${have}, blok wymaga ${range}. ` +
-                    `Zaktualizuj ją samodzielnie i uruchom ponownie.`);
+        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}`);
             }
         }
     }
     if (missing.size > 0) {
-        log.warn(`Brakujące zależności npm — zainstaluj je: ${[...missing].join(' ')}`);
+        // 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 toTuple(version) {
-    const [maj = 0, min = 0, patch = 0] = version.replace(/^[^\d]*/, '').split('.').map((n) => parseInt(n, 10) || 0);
-    return [maj, min, patch];
-}
-/** Prosty test: czy `have` jest poniżej minimum z zakresu (`^`, `~`, `>=`). */
-function belowMinimum(have, range) {
-    const [hM, hm, hp] = toTuple(have);
-    const [rM, rm, rp] = toTuple(range);
-    if (hM !== rM)
-        return hM < rM;
-    if (hm !== rm)
-        return hm < rm;
-    return hp < rp;
+    for (const note of peerNotes)
+        log.warn(note);
 }
 function printSummary(installed, metas, dryRun) {
     log.info(`\n${dryRun ? 'Zainstalowałbym' : 'Zainstalowano'}: ${installed.join(', ')}`);

package/dist/semver.js

@@ -0,0 +1,73 @@
+// Minimalna obsługa zakresów semver. CLI ma zero zależności runtime
+// (package.json → "dependencies": {}), więc zamiast paczki `semver` niesiemy tyle
+// kodu, ile pokrywa realne kształty zakresów z registry i z package.json aplikacji:
+// ">=0.6.0 <1.0.0", "^22.0.0", "~1.2.3", "1.2.3", oraz alternatywy przez "||".
+//
+// Zasada bezpieczeństwa: czego nie rozumiemy, tego nie oceniamy. Zablokowanie
+// instalacji z powodu składni nieznanej naszemu parserowi byłoby gorsze niż
+// pominięcie kontroli — stąd `satisfies` zwraca `true` dla zakresów, których nie
+// potrafi rozłożyć.
+/** Wyciąga trójkę z wersji; toleruje prefiksy (`v1.2.3`) i sufiksy (`1.2.3-rc.1`). */
+export function parseVersion(input) {
+    const m = /^[^\d]*(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(input.trim());
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+export function compare(a, b) {
+    for (let i = 0; i < 3; i++) {
+        if (a[i] !== b[i])
+            return a[i] < b[i] ? -1 : 1;
+    }
+    return 0;
+}
+/** Górna granica `^`: dla 0.x zawęża się do minora (0.6.x), a od 1.0 do majora. */
+function caretUpper([maj, min, patch]) {
+    if (maj > 0)
+        return [maj + 1, 0, 0];
+    if (min > 0)
+        return [0, min + 1, 0];
+    return [0, 0, patch + 1];
+}
+/** Pojedynczy komparator. `null` = nie rozumiem tego kształtu. */
+function satisfiesOne(version, comparator) {
+    const m = /^(>=|<=|>|<|=|\^|~|)\s*(.+)$/.exec(comparator.trim());
+    if (!m)
+        return null;
+    const [, op, rest] = m;
+    if (/[x*]/i.test(rest))
+        return null; // 1.x / 1.* — poza zakresem tego parsera
+    const target = parseVersion(rest);
+    if (!target)
+        return null;
+    switch (op) {
+        case '>=': return compare(version, target) >= 0;
+        case '<=': return compare(version, target) <= 0;
+        case '>': return compare(version, target) > 0;
+        case '<': return compare(version, target) < 0;
+        case '^': return compare(version, target) >= 0 && compare(version, caretUpper(target)) < 0;
+        case '~': return compare(version, target) >= 0 && compare(version, [target[0], target[1] + 1, 0]) < 0;
+        default: return compare(version, target) === 0; // '=' albo goła wersja
+    }
+}
+/**
+ * Czy `version` mieści się w `range`. Obsługuje koniunkcję przez spację
+ * (">=0.6.0 <1.0.0") i alternatywę przez "||". Zakres, którego nie da się
+ * rozłożyć, traktujemy jako spełniony — patrz nagłówek pliku.
+ */
+export function satisfies(version, range) {
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return true;
+    for (const alternative of range.split('||')) {
+        const comparators = alternative.trim().split(/\s+/).filter(Boolean);
+        if (comparators.length === 0)
+            continue;
+        const results = comparators.map((c) => satisfiesOne(parsed, c));
+        if (results.some((r) => r === null))
+            return true; // nieznany kształt — nie oceniamy
+        if (results.every(Boolean))
+            return true;
+    }
+    return false;
+}

package/package.json

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