@konce-pt/ui 0.7.11 → 0.8.0

package/dist/commands/add.js

@@ -7,7 +7,7 @@ import { satisfies } from "../semver.js";
 export async function addCommand(args) {
     const requested = args.positionals;
     if (requested.length === 0)
-        throw new UserError('Podaj nazwę bloku: add <nazwa...>');
+        throw new UserError('Give a block name: add <name...>');
     const { path: configPath, config } = requireConfig(process.cwd());
     const ctx = {
         base: flag(args, 'registry') ?? config.registry,
@@ -24,7 +24,7 @@ export async function addCommand(args) {
     const toInstall = order.filter((name) => ctx.overwrite || !config.installedBlocks[name]);
     logAlreadyInstalled(order, ctx);
     if (toInstall.length === 0) {
-        log.info('Nic do zrobienia.');
+        log.info('Nothing to do.');
         return;
     }
     // 3) Wczytaj definicje, sprawdź zależności npm.
@@ -36,7 +36,7 @@ export async function addCommand(args) {
     const plan = await planWrites(toInstall, metas, ctx);
     // 5) Zapis (albo raport dry-run).
     if (dryRun) {
-        log.info('— dry-run: żadnych zapisów —');
+        log.info('— dry-run: nothing written —');
         for (const p of plan)
             log.step(`${labelFor(p.action)}  ${p.target}`);
     }
@@ -57,7 +57,7 @@ function resolveOrder(requested, index) {
         if (done.has(name))
             return;
         if (stack.has(name))
-            throw new UserError(`Cykl zależności registry wokół bloku "${name}".`);
+            throw new UserError(`A registry dependency cycle around the block "${name}".`);
         const entry = index.blocks.find((b) => b.name === name);
         if (!entry)
             throw new UserError(unknownBlockMessage(name, index));
@@ -77,7 +77,7 @@ function logAlreadyInstalled(order, ctx) {
         return;
     for (const name of order) {
         if (ctx.config.installedBlocks[name]) {
-            log.step(`${name} — już zainstalowany (pomijam; --overwrite by nadpisać)`);
+            log.step(`${name} — already installed (skipping; --overwrite would replace it)`);
         }
     }
 }
@@ -98,7 +98,7 @@ async function planWrites(toInstall, metas, ctx) {
 function applyPlan(plan, projectRoot) {
     for (const p of plan) {
         if (p.action === 'skip-identical') {
-            log.step(`bez zmian  ${p.target}`);
+            log.step(`unchanged  ${p.target}`);
             continue;
         }
         const dest = p.action === 'conflict-new' ? `${p.absolute}.new` : p.absolute;
@@ -126,10 +126,10 @@ function planWrite(block, absolute, content, projectRoot, overwrite) {
 }
 function labelFor(action) {
     switch (action) {
-        case 'write': return 'nowy     ';
-        case 'overwrite': return 'nadpisano';
-        case 'conflict-new': return 'konflikt→.new';
-        case 'skip-identical': return 'bez zmian';
+        case 'write': return 'new      ';
+        case 'overwrite': return 'overwrote';
+        case 'conflict-new': return 'conflict→.new';
+        case 'skip-identical': return 'unchanged';
     }
 }
 /** Przepisuje placeholdery: `@/` → alias, selektory `kpt-` → prefix (nie rusza `--kpt-`). */
@@ -163,14 +163,14 @@ function checkNpmDependencies(metas, projectRoot) {
             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.`);
+                throw new UserError(`The ${name} dependency is at version ${have}, the block needs ${range}. ` +
+                    `Update it yourself and run this again.`);
             }
             continue;
         }
         peerNotes.add(verdict === 'missing'
-            ? `${name} (peer) — brak w projekcie, blok wymaga ${range}`
-            : `${name} (peer) jest w wersji ${have}, blok wymaga ${range}`);
+            ? `${name} (peer) — not in the project, the block needs ${range}`
+            : `${name} (peer) is at version ${have}, the block needs ${range}`);
     }
     reportMissing(missing);
     for (const note of peerNotes)
@@ -212,12 +212,12 @@ function reportMissing(missing) {
         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(' ')}`);
+    log.warn(`Missing npm dependencies — install them: ${[...missing.keys()].join(' ')}`);
     for (const [name, range] of missing)
-        log.step(`${name} wymaga ${range}`);
+        log.step(`${name} needs ${range}`);
 }
 function printSummary(installed, metas, dryRun) {
-    log.info(`\n${dryRun ? 'Zainstalowałbym' : 'Zainstalowano'}: ${installed.join(', ')}`);
+    log.info(`\n${dryRun ? 'Would install' : 'Installed'}: ${installed.join(', ')}`);
     for (const name of installed) {
         const meta = metas.get(name);
         if (meta.usage) {
@@ -226,18 +226,18 @@ function printSummary(installed, metas, dryRun) {
         }
         const ports = meta.api?.ports ?? [];
         for (const port of ports) {
-            log.warn(`port do podpięcia: ${port.token} — ${port.signature}${port.stubProvided ? ' (stub w komplecie)' : ''}`);
+            log.warn(`port to wire up: ${port.token} — ${port.signature}${port.stubProvided ? ' (a stub is included)' : ''}`);
         }
         if (meta.notes)
-            log.step(`uwaga: ${meta.notes}`);
+            log.step(`note: ${meta.notes}`);
     }
 }
 function unknownBlockMessage(name, index) {
     const nearest = index.blocks
         .map((b) => ({ name: b.name, d: levenshtein(name, b.name) }))
         .sort((a, b) => a.d - b.d)[0];
-    const hint = nearest && nearest.d <= 3 ? ` Czy chodziło o "${nearest.name}"?` : '';
-    return `Nie znam bloku "${name}".${hint} Zobacz: npx @konce-pt/ui list`;
+    const hint = nearest && nearest.d <= 3 ? ` Did you mean "${nearest.name}"?` : '';
+    return `I do not know the block "${name}".${hint} See: npx @konce-pt/ui list`;
 }
 function levenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, (_, i) => i);

package/dist/commands/init.js

@@ -6,7 +6,7 @@ export function initCommand(args) {
     const cwd = process.cwd();
     const configPath = path.join(cwd, CONFIG_FILE);
     if (existsSync(configPath) && !hasFlag(args, 'force')) {
-        throw new UserError(`${CONFIG_FILE} już istnieje. Użyj --force, aby nadpisać.`);
+        throw new UserError(`${CONFIG_FILE} already exists. Use --force to overwrite it.`);
     }
     const config = {
         ...DEFAULT_CONFIG,
@@ -18,10 +18,10 @@ export function initCommand(args) {
         installedBlocks: {},
     };
     writeConfig(configPath, config);
-    log.ok(`Utworzono ${CONFIG_FILE}`);
+    log.ok(`Created ${CONFIG_FILE}`);
     log.step(`registry:  ${config.registry}`);
     log.step(`blocksDir: ${config.blocksDir}`);
     log.step(`alias:     ${config.alias}`);
     log.step(`prefix:    ${config.prefix}`);
-    log.info('\nDodaj blok: npx @konce-pt/ui add <nazwa>');
+    log.info('\nAdd a block: npx @konce-pt/ui add <name>');
 }

package/dist/commands/list.js

@@ -17,14 +17,14 @@ export async function listCommand(args) {
     const index = await loadIndex(base);
     const blocks = category ? index.blocks.filter((b) => b.category === category) : index.blocks;
     if (blocks.length === 0) {
-        log.warn(category ? `Brak bloków w kategorii "${category}".` : 'Registry nie zawiera bloków.');
+        log.warn(category ? `No blocks in the "${category}" category.` : 'The registry contains no blocks.');
         return;
     }
-    log.info(`Bloki @konce-pt (biblioteka ${index.libraryVersion}):\n`);
+    log.info(`@konce-pt blocks (library ${index.libraryVersion}):\n`);
     const width = Math.max(...blocks.map((b) => b.name.length));
     for (const b of blocks) {
         log.info(`  ${b.name.padEnd(width)}  ${b.title}  [${b.category}]`);
         log.info(`  ${' '.repeat(width)}  ${b.description}`);
     }
-    log.info('\nZainstaluj: npx @konce-pt/ui add <nazwa>');
+    log.info('\nInstall: npx @konce-pt/ui add <name>');
 }

package/dist/config.js

@@ -34,7 +34,7 @@ export function writeConfig(configPath, cfg) {
 export function requireConfig(cwd) {
     const configPath = findConfigPath(cwd);
     if (!configPath) {
-        throw new UserError(`Brak ${CONFIG_FILE}. Uruchom najpierw: npx @konce-pt/ui init`);
+        throw new UserError(`No ${CONFIG_FILE}. Run this first: npx @konce-pt/ui init`);
     }
     return { path: configPath, config: readConfig(configPath) };
 }

package/dist/index.js

@@ -3,17 +3,18 @@ import { parseArgs, log, UserError } from "./util.js";
 import { initCommand } from "./commands/init.js";
 import { listCommand } from "./commands/list.js";
 import { addCommand } from "./commands/add.js";
-const HELP = `Koncept UI — CLI bloków.
+const HELP = `Koncept UI — the block CLI.
 
-Użycie:
-  npx @konce-pt/ui <komenda> [opcje]
+Usage:
+  npx @konce-pt/ui <command> [options]
 
-Komendy:
-  init                     utwórz konce.json (--registry --blocks-dir --alias --prefix --theme --force)
-  add <nazwa...>           zainstaluj blok(i) + zależności (--overwrite --dry-run --path --registry)
-  list [--category=...]    pokaż dostępne bloki (--registry)
+Commands:
+  init                     create konce.json (--registry --blocks-dir --alias --prefix --theme --force)
+  add <name...>            install block(s) + their dependencies (--overwrite --dry-run --path --registry)
+  list [--category=...]    show the available blocks (--registry)
 
-Kody wyjścia: 0 ok, 1 błąd.`;
+Options take a value only as --key=value.
+Exit codes: 0 ok, 1 error.`;
 async function main() {
     const [command, ...rest] = process.argv.slice(2);
     const args = parseArgs(rest);
@@ -34,7 +35,7 @@ async function main() {
             log.info(HELP);
             break;
         default:
-            throw new UserError(`Nieznana komenda "${command}". Zobacz: npx @konce-pt/ui --help`);
+            throw new UserError(`Unknown command "${command}". See: npx @konce-pt/ui --help`);
     }
 }
 main().catch((err) => {

package/dist/registry.js

@@ -7,12 +7,12 @@ async function fetchText(base, relPath) {
         const url = `${base.replace(/\/$/, '')}/${relPath}`;
         const res = await fetch(url);
         if (!res.ok)
-            throw new UserError(`Nie udało się pobrać ${url} (HTTP ${res.status}).`);
+            throw new UserError(`Could not fetch ${url} (HTTP ${res.status}).`);
         return res.text();
     }
     const file = path.resolve(base, relPath);
     if (!existsSync(file))
-        throw new UserError(`Brak pliku w registry: ${file}`);
+        throw new UserError(`Missing file in the registry: ${file}`);
     return readFileSync(file, 'utf8');
 }
 export async function loadIndex(base) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@konce-pt/ui",
-  "version": "0.7.11",
-  "description": "CLI Koncept UI — instaluje bloki (copy-paste) do projektu Angular: init, add, list.",
+  "version": "0.8.0",
+  "description": "The Koncept UI CLI — installs blocks (copy-paste) into an Angular project: init, add, list.",
   "license": "MIT",
   "author": "konce.pt",
   "homepage": "https://ui.konce.pt/",