orbital-ds 0.13.2 → 0.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/scripts/init.mjs CHANGED
@@ -28,6 +28,9 @@
28
28
  * --no-marker apaga el rotulador del tema (si el tema lo tiene)
29
29
  * --out <fichero> fichero de marca (por defecto src/brand.css)
30
30
  * --update reescribe el bloque generado si ya existe
31
+ * --clean <alcance> desactiva lo escrito A MANO en brand.css (se comenta, con copia .bak):
32
+ * colors = colores y variables privadas de un tema (radios y fuentes se quedan) · all = todo
33
+ * --remember-brand (modo fiel) al quitar la marca generada, la recuerda para recuperarla al volver
31
34
  * --dry-run muestra el resultado sin escribir nada
32
35
  * --wizard fuerza el asistente aunque no haya terminal interactiva
33
36
  * --yes no pregunta (usa los valores dados)
@@ -62,7 +65,8 @@ const flag = (n) => args.includes(`--${n}`);
62
65
  const opt = (n) => { const i = args.indexOf(`--${n}`); return i > -1 && args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : undefined; };
63
66
 
64
67
  import { parseColor, derivar, hex, ratio, rgbToOklch, ok } from './brand-core.mjs';
65
- import { detectarCssApp, conectarCss, gestorPaquetes, comandoInstalar, instalar, yaInstalado } from './setup.mjs';
68
+ import { detectarCssApp, detectarMarca, temaDelCss, conectarCss, importsDeTemaSueltos, quitarImportsSueltos, gestorPaquetes, comandoInstalar, instalar, yaInstalado } from './setup.mjs';
69
+ import { bloqueCss, escribirBloque, tieneBloque, quitarBloque, marcaGenerada, analizarMarca, desactivarMarca, nombresColorTemas, fijarTemaBase } from './brand-file.mjs';
66
70
  import { instalarSkill, usaClaude, estadoSkill } from './skill.mjs';
67
71
 
68
72
  /** Ruta relativa al directorio de trabajo, con barras normales (para mostrarla). */
@@ -71,52 +75,6 @@ const relPath = (f) => f.replace(process.cwd(), '.').split('\\').join('/');
71
75
  /* ═══════════════════════════════ SALIDA ══════════════════════════════════════ */
72
76
  const TTY_COLOR = process.stdout.isTTY && (process.env.COLORTERM === 'truecolor' || process.env.COLORTERM === '24bit' || process.env.WT_SESSION);
73
77
  const muestra = (c) => (TTY_COLOR ? `\x1b[48;2;${c.r};${c.g};${c.b}m \x1b[0m ` : '');
74
- const INI = '/* orbital-ds:brand:start */';
75
- const FIN = '/* orbital-ds:brand:end */';
76
-
77
- function bloqueCss(res, { tema, primario, modo = 'full' }) {
78
- const fmt = (tokens) => Object.entries(tokens).map(([k, v]) => ` --${k}: ${v};`).join('\n');
79
- return `${INI}
80
- /* Generado por \`orbital-ds-init\` (tema ${tema}, primario ${primario}, modo ${modo}). Si vuelves a
81
- * ejecutarlo con --update, solo se reescribe este bloque; lo que tengas fuera no se toca. */
82
- :root {
83
- ${fmt(res.claro)}
84
- }
85
- .dark {
86
- ${fmt(res.oscuro)}
87
- }
88
- ${FIN}
89
- `;
90
- }
91
-
92
- function escribirBloque(file, bloque) {
93
- const actual = existsSync(file) ? readFileSync(file, 'utf8') : null;
94
- if (actual === null) {
95
- mkdirSync(dirname(file), { recursive: true });
96
- writeFileSync(file, `/*\n * MARCA de la app — fichero TUYO. Se importa DESPUÉS del tema, así que lo que pongas aquí gana.\n */\n\n${bloque}`);
97
- return 'creado';
98
- }
99
- if (actual.includes(INI) && actual.includes(FIN)) {
100
- const nuevo = actual.slice(0, actual.indexOf(INI)) + bloque.trimEnd() + actual.slice(actual.indexOf(FIN) + FIN.length);
101
- if (nuevo === actual) return 'igual';
102
- writeFileSync(file, nuevo);
103
- return 'actualizado';
104
- }
105
- writeFileSync(file, `${actual.replace(/\s*$/, '')}\n\n${bloque}`);
106
- return 'añadido';
107
- }
108
-
109
- /** ¿El fichero de marca tiene un bloque generado? */
110
- const tieneBloque = (file) => existsSync(file) && readFileSync(file, 'utf8').includes(INI) && readFileSync(file, 'utf8').includes(FIN);
111
-
112
- /** Quita SOLO el bloque generado (modo fiel); lo que la app tenga fuera se queda. */
113
- function quitarBloque(file) {
114
- if (!tieneBloque(file)) return 'sin bloque';
115
- const actual = readFileSync(file, 'utf8');
116
- const nuevo = (actual.slice(0, actual.indexOf(INI)).replace(/\s*$/, '') + '\n' + actual.slice(actual.indexOf(FIN) + FIN.length).replace(/^\s*/, '\n')).replace(/\n{3,}/g, '\n\n');
117
- writeFileSync(file, nuevo);
118
- return 'quitado';
119
- }
120
78
 
121
79
  /** brand.css de la app: si no existe, la plantilla comentada (vacía: el tema se ve tal cual). */
122
80
  function asegurarMarca(out) {
@@ -127,6 +85,47 @@ function asegurarMarca(out) {
127
85
  return 'creado';
128
86
  }
129
87
 
88
+ /* ═══════════════════════════════ LIMPIEZA ════════════════════════════════════ */
89
+ /**
90
+ * Lo que brand.css tiene escrito A MANO (fuera del bloque generado) y taparía al tema:
91
+ * los colores (paleta del tema anterior) y las variables privadas de un tema.
92
+ */
93
+ const manualDe = (out) => analizarMarca(out, { nombresColor: NOMBRES_COLOR });
94
+
95
+ /** Resumen corto de unas declaraciones: «--background #f4f5fb, --primary #4b5bbf… (+22)». */
96
+ const resumenDecl = (decl, n = 6) => `${decl.slice(0, n).map((d) => `${d.name} ${d.value}`).join(', ')}${decl.length > n ? `… (+${decl.length - n})` : ''}`;
97
+
98
+ const LIMPIEZAS = {
99
+ colors: { label: 'Quitar esos colores', hint: 'se comentan (con copia .bak); radios, fuentes y movimiento se quedan' },
100
+ all: { label: 'Dejar brand.css limpio', hint: 'se comenta todo lo escrito a mano (con copia .bak)' },
101
+ keep: { label: 'Conservarlos', hint: 'seguirán ganando al tema' },
102
+ };
103
+
104
+ /**
105
+ * Desactiva lo escrito a mano en brand.css: `colors` (paleta y variables privadas de un tema) o `all`.
106
+ * Devuelve el texto que se enseña.
107
+ */
108
+ function limpiarMarca(out, alcance, { de, a }) {
109
+ const filtro = alcance === 'all' ? () => true : (d) => d.color || d.privada;
110
+ const motivo = de && de !== a ? `al pasar de «${de}» a «${a}»` : `para usar «${a}» ${alcance === 'all' ? 'sin ajustes propios' : 'con sus colores'}`;
111
+ const r = desactivarMarca(out, filtro, { etiqueta: de ?? 'anterior', motivo, nombresColor: NOMBRES_COLOR });
112
+ const lineas = [];
113
+ if (r.desactivadas.length) lineas.push(`Desactivadas ${r.desactivadas.length} variable(s) de ${relPath(out)} (copia en ${relPath(r.copia)}).`);
114
+ if (r.revisar.length) lineas.push(`Revisa a mano (comparten línea o comentario con otras): ${r.revisar.map((d) => `${d.name} (línea ${d.linea})`).join(', ')}`);
115
+ if (r.huerfanas.length) lineas.push(`Revisa a mano: estas reglas tuyas usaban una variable desactivada y ya no pintan: ${r.huerfanas.map((h) => `${h.name} (línea ${h.linea})`).join(', ')}. Cámbialas por una pública (--sidebar-accent, --primary…) o bórralas.`);
116
+ return lineas.join('\n') || 'Nada que limpiar en la marca.';
117
+ }
118
+
119
+ /** Quita los imports de tema que la app tiene FUERA del bloque de su CSS (otros CSS, JS de entrada, HTML). */
120
+ function limpiarImports(css) {
121
+ const sueltos = importsDeTemaSueltos(css);
122
+ const quitados = quitarImportsSueltos(sueltos);
123
+ const lineas = sueltos.filter((x) => x.sola).map((x) => `Quitado de ${relPath(x.fichero)}:${x.linea}: ${x.texto}`);
124
+ const manual = sueltos.filter((x) => !x.sola);
125
+ if (manual.length) lineas.push(`Revisa a mano (otro tema cargado aparte): ${manual.map((x) => `${relPath(x.fichero)}:${x.linea}`).join(', ')}`);
126
+ return { lineas, quitados };
127
+ }
128
+
130
129
  /* ═══════════════════════════════ MODOS ═══════════════════════════════════════ */
131
130
  const MODOS = {
132
131
  faithful: { label: 'Fiel al tema', hint: 'su paleta tal cual; no se deriva nada' },
@@ -140,12 +139,14 @@ const soloPrimario = (tokens) => Object.fromEntries(Object.entries(tokens).filte
140
139
  /* ═══════════════════════════════ TEMAS ═══════════════════════════════════════ */
141
140
  const temasDir = existsSync(join(ROOT, 'src/themes')) ? join(ROOT, 'src/themes') : join(ROOT, 'dist/themes');
142
141
  const temas = readdirSync(temasDir).filter((f) => f.endsWith('.meta.json')).map((f) => JSON.parse(readFileSync(join(temasDir, f), 'utf8')));
143
- const TEMA_CSS = (() => {
144
- for (const f of [detectarCssApp(), 'src/styles.css', 'app/styles.css', 'src/index.css']) {
145
- if (f && existsSync(f)) { const m = readFileSync(f, 'utf8').match(/orbital-ds\/themes\/([\w-]+)\.css/); if (m) return m[1]; }
146
- }
147
- return 'qratia';
148
- })();
142
+ const CSS_APP = opt('css') ? resolve(opt('css')) : detectarCssApp();
143
+ /** Tema que importa hoy el CSS de la app (o null si aún no está conectado). */
144
+ const TEMA_ACTUAL = temaDelCss(CSS_APP);
145
+ const TEMA_CSS = TEMA_ACTUAL ?? 'qratia';
146
+ /** Fichero de marca: el que importa el CSS de la app (o --out, o src/brand.css). */
147
+ const OUT = resolve(opt('out') ?? detectarMarca(CSS_APP));
148
+ /** Nombres de las variables de color de los temas: una de ellas en brand.css es un color «del tema anterior». */
149
+ const NOMBRES_COLOR = nombresColorTemas(temasDir);
149
150
  const ficha = (tema) => temas.find((t) => t.name === tema) ?? {};
150
151
  /** Un tema tiene gestos si su ficha (`<tema>.meta.json`) los declara con variables públicas. */
151
152
  const tieneGestos = (tema) => (ficha(tema).gestures ?? []).length > 0;
@@ -216,7 +217,44 @@ function paresPrimario(res, tema) {
216
217
  }
217
218
 
218
219
  /** Calcula la marca según el modo. */
219
- function calcular(modo, tema, primario, { acento, secundario = null, marcador = true }) {
220
+ /** Variables del tema tal como se escriben (sin resolver `var()`), por piel. */
221
+ function crudoTema(tema) {
222
+ const f = join(temasDir, `${tema}.css`);
223
+ const claro = {}, oscuro = {};
224
+ if (!existsSync(f)) return { claro, oscuro };
225
+ const css = readFileSync(f, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '');
226
+ // Solo los bloques de primer nivel (no los de @media): son los valores de fábrica.
227
+ for (const [, sel, cuerpo] of css.matchAll(/^(:root|\.dark)\s*\{([^{}]*)\}/gm)) {
228
+ for (const [, k, v] of cuerpo.matchAll(/--([\w-]+)\s*:\s*([^;]+);/g)) (sel === ':root' ? claro : oscuro)[k] = v.trim();
229
+ }
230
+ return { claro, oscuro: { ...claro, ...oscuro } };
231
+ }
232
+
233
+ /**
234
+ * Ajusta la marca derivada a lo que el tema ya resuelve por su cuenta:
235
+ * - un token que el tema define como MATERIAL (`var(--lq-glass)`: cristal del lateral o de los menús) no se
236
+ * pisa con un color opaco: se queda el del tema;
237
+ * - el hover del primario, si el tema lo fija con un color, se recalcula desde el primario nuevo (si no,
238
+ * el botón cambiaría al azul del tema al pasar el ratón).
239
+ */
240
+ function ajustarAlTema(tokens, crudo, oscura) {
241
+ const res = Object.fromEntries(Object.entries(tokens).filter(([k]) => !/^var\(--(?!ds-)[\w-]+\)$/.test(crudo[k] ?? '')));
242
+ const prim = parseColor(res.primary ?? '');
243
+ if (prim && parseColor(crudo['ds-button-primary-hover'] ?? '')) {
244
+ const o = rgbToOklch(prim);
245
+ res['ds-button-primary-hover'] = hex(ok(Math.min(0.97, Math.max(0.05, o.l + (oscura ? 0.06 : -0.06))), o.c, o.h));
246
+ if (crudo['ds-button-primary-hover-fg']) res['ds-button-primary-hover-fg'] = res['primary-foreground'];
247
+ }
248
+ return res;
249
+ }
250
+
251
+ function calcular(modo, tema, primario, opciones) {
252
+ const res = calcularBase(modo, tema, primario, opciones);
253
+ const crudo = crudoTema(tema);
254
+ return { ...res, claro: ajustarAlTema(res.claro, crudo.claro, false), oscuro: ajustarAlTema(res.oscuro, crudo.oscuro, true) };
255
+ }
256
+
257
+ function calcularBase(modo, tema, primario, { acento, secundario = null, marcador = true }) {
220
258
  const gestos = tieneGestos(tema);
221
259
  if (modo === 'primary') {
222
260
  const res = derivar(primario, { acento, secundario, marcador, gestos, base: baseTema(tema) });
@@ -234,7 +272,7 @@ function calcular(modo, tema, primario, { acento, secundario = null, marcador =
234
272
 
235
273
  /* ═══════════════════════════════ FLUJO ═══════════════════════════════════════ */
236
274
  function plantillaClasica() {
237
- const out = resolve(opt('out') ?? 'src/brand.css');
275
+ const out = OUT;
238
276
  if (existsSync(out)) console.log(`Ya existe ${out}: no se toca (es de tu app).`);
239
277
  else {
240
278
  const lines = contract.brand.tokens.map((t) => ` /* --${t.name}: ${t.example}; */ /* ${t.about} */`);
@@ -343,6 +381,19 @@ async function asistente() {
343
381
  'Bienvenida',
344
382
  );
345
383
 
384
+ // Lo que hay hoy: tema conectado, marca generada (o recordada) y colores escritos a mano en brand.css.
385
+ const out = OUT;
386
+ const generada = marcaGenerada(out);
387
+ const manual = manualDe(out);
388
+ const primManual = manual.primario ? parseColor(manual.primario) : null;
389
+ if (TEMA_ACTUAL || generada || manual.decl.length) {
390
+ p.log.info([
391
+ `Ahora: tema ${TEMA_ACTUAL ?? '(sin conectar)'}`,
392
+ generada?.activa ? `marca generada desde ${generada.primario} (modo ${generada.modo})` : null,
393
+ manual.colores.length ? `${manual.colores.length} color(es) escritos a mano en ${relPath(out)}` : null,
394
+ ].filter(Boolean).join(' · '));
395
+ }
396
+
346
397
  /* 1 · Tema */
347
398
  const tema = salir(await p.select({
348
399
  message: '1/4 · ¿Qué tema quieres usar?',
@@ -350,24 +401,28 @@ async function asistente() {
350
401
  options: temas.map((t) => ({ value: t.name, label: t.label ? `${t.label} (${t.name})` : t.name, hint: t.essence })),
351
402
  }));
352
403
  p.note(resumenFicha(tema), `Tema «${tema}»`);
404
+ const cambiaTema = Boolean(TEMA_ACTUAL && TEMA_ACTUAL !== tema);
353
405
 
354
406
  /* 2 · Colores */
355
407
  const recomendado = modoRecomendado(tema);
408
+ // Por defecto, lo que ya tenías (salvo en un tema corporativo, que se usa fiel): tu modo, o «solo
409
+ // primario» si tu primario está escrito a mano.
410
+ const modoInicial = recomendado === 'faithful' ? recomendado : generada?.modo ?? (primManual ? 'primary' : recomendado);
356
411
  const modo = salir(await p.select({
357
412
  message: '2/4 · ¿Cómo quieres los colores?',
358
- initialValue: recomendado,
413
+ initialValue: modoInicial,
359
414
  options: Object.entries(MODOS).map(([value, m]) => ({ value, label: value === recomendado ? `${m.label} (recomendado)` : m.label, hint: m.hint })),
360
415
  }));
361
416
 
362
- const out = resolve(opt('out') ?? 'src/brand.css');
363
- let res = null, primario = null, secundario = null;
417
+ let res = null, primario = null, secundario = generada?.secundario ? parseColor(generada.secundario) : null, marcador = generada?.marcador ?? true;
418
+ const primarioPrevio = generada?.primario ?? (primManual ? hex(primManual) : undefined);
364
419
  if (modo !== 'faithful') {
365
420
  const gestos = tieneGestos(tema);
366
421
  for (;;) {
367
422
  primario = parseColor(salir(await p.text({
368
- message: modo === 'primary' ? 'Color principal de tu marca (el resto de la paleta será la del tema)' : 'Color principal de tu marca',
423
+ message: `${modo === 'primary' ? 'Color principal de tu marca (el resto de la paleta será la del tema)' : 'Color principal de tu marca'}${!primario && primarioPrevio ? ` · el actual es ${primarioPrevio}` : ''}`,
369
424
  placeholder: '#1D63D8 · rgb(29 99 216) · hsl(219 76% 48%) · oklch(0.55 0.2 260)',
370
- initialValue: primario ? hex(primario) : undefined,
425
+ initialValue: primario ? hex(primario) : primarioPrevio,
371
426
  validate: (v) => (v && parseColor(v) ? undefined : 'No entiendo ese color. Prueba con #1D63D8, rgb(), hsl() u oklch().'),
372
427
  })));
373
428
  const quiereSec = salir(await p.confirm({
@@ -376,19 +431,25 @@ async function asistente() {
376
431
  message: `¿Añades un color secundario?${gestos ? ' (se usa en los gráficos y en el gesto del tema)' : ' (se usa como segunda serie de los gráficos)'}`,
377
432
  initialValue: Boolean(secundario),
378
433
  }));
434
+ const secPrevio = secundario;
379
435
  secundario = null;
380
436
  if (quiereSec) {
381
437
  const P = rgbToOklch(primario);
382
438
  const prop = [['complementario', 180], ['análogo', 35], ['triádico', 120]].map(([n, d]) => [n, ok(0.7, Math.max(0.12, Math.min(P.c, 0.18)), (P.h + d) % 360)]);
383
439
  const elegido = salir(await p.select({
384
440
  message: 'Color secundario',
385
- options: [...prop.map(([n, c]) => ({ value: hex(c), label: `${muestra(c)}${n}`, hint: hex(c) })), { value: 'otro', label: 'Otro color…' }],
441
+ initialValue: secPrevio ? hex(secPrevio) : undefined,
442
+ options: [
443
+ ...(secPrevio ? [{ value: hex(secPrevio), label: `${muestra(secPrevio)}el actual`, hint: hex(secPrevio) }] : []),
444
+ ...prop.map(([n, c]) => ({ value: hex(c), label: `${muestra(c)}${n}`, hint: hex(c) })),
445
+ { value: 'otro', label: 'Otro color…' },
446
+ ],
386
447
  }));
387
448
  secundario = elegido === 'otro'
388
449
  ? parseColor(salir(await p.text({ message: 'Color secundario', validate: (v) => (parseColor(v ?? '') ? undefined : 'Color no válido') })))
389
450
  : parseColor(elegido);
390
451
  }
391
- const marcador = gestos ? salir(await p.confirm({ message: '¿Rotulador bajo los títulos? (gesto del tema)', active: 'Sí', inactive: 'No', initialValue: true })) : true;
452
+ marcador = gestos ? salir(await p.confirm({ message: '¿Rotulador bajo los títulos? (gesto del tema)', active: 'Sí', inactive: 'No', initialValue: marcador })) : true;
392
453
 
393
454
  res = calcular(modo, tema, primario, { secundario, marcador });
394
455
  p.note(
@@ -406,6 +467,27 @@ async function asistente() {
406
467
  }
407
468
  }
408
469
 
470
+ /* Colores escritos a mano: con otro tema (o en modo fiel) taparían al tema elegido. */
471
+ let limpieza = 'keep';
472
+ if (manual.colores.length) {
473
+ const rec = cambiaTema || modo === 'faithful' ? 'colors' : 'keep';
474
+ p.note(
475
+ [
476
+ `${relPath(out)} tiene ${manual.colores.length} color(es) escritos a mano${cambiaTema ? ` para «${TEMA_ACTUAL}»` : ''}:`,
477
+ ` ${resumenDecl(manual.colores)}`,
478
+ '',
479
+ `Se importa después del tema, así que ${cambiaTema ? `taparían los colores de «${tema}»` : 'ganan a los del tema'}${modo !== 'faithful' ? ' (tu marca generada, que va al final, gana donde coincidan)' : ''}.`,
480
+ ...(manual.privadas.length ? [`${manual.privadas.length} son variables privadas de un tema (${manual.privadas.map((d) => d.name).join(', ')}): no valen en otro.`] : []),
481
+ ].join('\n'),
482
+ 'Colores escritos a mano',
483
+ );
484
+ limpieza = salir(await p.select({
485
+ message: '¿Qué hago con ellos?',
486
+ initialValue: rec,
487
+ options: Object.entries(LIMPIEZAS).map(([value, l]) => ({ value, label: value === rec ? `${l.label} (recomendado)` : l.label, hint: l.hint })),
488
+ }));
489
+ }
490
+
409
491
  /* 3 · Extras */
410
492
  const gestor = gestorPaquetes();
411
493
  const locales = ['src/i18n/locales', 'src/locales', 'locales', 'public/locales'].find((d) => existsSync(d));
@@ -419,9 +501,10 @@ async function asistente() {
419
501
  const conIdiomas = locales ? salir(await p.confirm({ message: `¿Sincronizo los textos de orbital-ds en tus idiomas (${locales})?`, active: 'Sí', inactive: 'No', initialValue: true })) : false;
420
502
 
421
503
  /* 4 · Resumen y aplicar */
422
- const css = detectarCssApp() ?? resolve('src/index.css');
504
+ const css = CSS_APP ?? resolve('src/index.css');
423
505
  const paquetes = [...new Set(extras.flatMap((e) => EXTRAS[e].pkgs ?? []))].filter((x) => !yaInstalado(x));
424
506
  const bloqueViejo = tieneBloque(out);
507
+ const sueltos = importsDeTemaSueltos(css).filter((x) => x.sola);
425
508
  const pasoMarca =
426
509
  modo === 'faithful'
427
510
  ? bloqueViejo
@@ -429,8 +512,10 @@ async function asistente() {
429
512
  : `${existsSync(out) ? 'Dejar' : 'Crear'} ${relPath(out)} sin cambios de paleta`
430
513
  : `Escribir tu marca en ${relPath(out)} (solo un bloque delimitado)`;
431
514
  const pasos = [
515
+ ...(limpieza !== 'keep' ? [`Desactivar en ${relPath(out)} ${limpieza === 'all' ? 'todo lo escrito a mano' : `${manual.colores.length} color(es) escritos a mano`} (con copia .bak)`] : []),
432
516
  pasoMarca,
433
- `Conectar ${relPath(css)}: fuentes, Tailwind, estructura, tema${extras.includes('animations') ? ', animaciones' : ''} y marca, en orden`,
517
+ `Conectar ${relPath(css)}: fuentes, Tailwind, estructura, tema${extras.includes('animations') ? ', animaciones' : ''} y marca, en orden${cambiaTema ? ` (sale «${TEMA_ACTUAL}»)` : ''}`,
518
+ ...(sueltos.length ? [`Quitar ${sueltos.length} import(s) de tema cargados aparte: ${[...new Set(sueltos.map((x) => relPath(x.fichero)))].join(', ')}`] : []),
434
519
  ...(paquetes.length ? [`Instalar con ${gestor}: ${paquetes.join(', ')}`] : []),
435
520
  ...(conIdiomas ? [`Rellenar el espacio «orbital» en ${locales}`] : []),
436
521
  ...(extras.includes('designer') ? ['Instalar el diseñador para Claude en .claude/skills/orbital-ds-designer'] : []),
@@ -440,13 +525,18 @@ async function asistente() {
440
525
  p.note(pasos.map((s) => `• ${s}`).join('\n'), '4/4 · Esto es lo que voy a hacer');
441
526
  if (!salir(await p.confirm({ message: '¿Lo aplico?', active: 'Sí', inactive: 'No', initialValue: true }))) { p.cancel('No se ha escrito nada.'); return; }
442
527
 
528
+ if (limpieza !== 'keep') p.log.success(limpiarMarca(out, limpieza, { de: TEMA_ACTUAL, a: tema }));
529
+ fijarTemaBase(out, tema);
443
530
  if (modo === 'faithful') {
444
- if (bloqueViejo) quitarBloque(out); else asegurarMarca(out);
531
+ // La marca generada se recuerda: orbital-ds theme la recupera al volver a un tema que la admita.
532
+ if (bloqueViejo) quitarBloque(out, generada?.activa ? { recordar: { params: generada, tema } } : {}); else asegurarMarca(out);
445
533
  p.log.success(`Marca: el tema «${tema}» se ve fiel (${relPath(out)}).`);
446
534
  } else {
447
- p.log.success(`Marca ${escribirBloque(out, bloqueCss(res, { tema, primario: hex(primario), modo }))} en ${relPath(out)}.`);
535
+ const params = { tema, primario: hex(primario), modo, secundario: secundario && hex(secundario), marcador };
536
+ p.log.success(`Marca ${escribirBloque(out, bloqueCss(res, params))} en ${relPath(out)}.`);
448
537
  }
449
538
  p.log.success(`CSS ${conectarCss(css, { tema, brandFile: out, motion: extras.includes('animations') })}: ${relPath(css)}.`);
539
+ for (const l of limpiarImports(css).lineas) p.log.warn(l);
450
540
  if (paquetes.length) {
451
541
  const s = p.spinner();
452
542
  s.start(`Instalando ${paquetes.join(', ')}…`);
@@ -494,14 +584,26 @@ async function directo() {
494
584
  if (!temas.some((t) => t.name === tema)) { console.error(`El tema «${tema}» no existe. Disponibles: ${temas.map((t) => t.name).join(', ')}`); process.exit(1); }
495
585
  const modo = opt('mode') ?? (opt('primary') ? 'full' : 'faithful');
496
586
  if (!MODOS[modo]) { console.error(`Modo «${modo}» no válido. Usa: ${Object.keys(MODOS).join(', ')}`); process.exit(1); }
497
- const out = resolve(opt('out') ?? 'src/brand.css');
587
+ if (modo !== 'faithful' && !parseColor(opt('primary') ?? '')) { console.error('Color primario no válido. Usa hex, rgb(), hsl() u oklch().'); process.exit(1); }
588
+ const out = OUT;
589
+ const limpieza = opt('clean');
590
+ if (limpieza && !['colors', 'all'].includes(limpieza)) { console.error(`--clean «${limpieza}» no válido. Usa: colors (los colores escritos a mano) · all (todo lo escrito a mano).`); process.exit(1); }
591
+ const manual = manualDe(out);
592
+ if (limpieza && !flag('dry-run')) console.log(limpiarMarca(out, limpieza, { de: TEMA_ACTUAL, a: tema }));
593
+ else if (manual.colores.length && TEMA_ACTUAL !== tema && !flag('keep-manual')) {
594
+ console.log(`Aviso: ${relPath(out)} tiene ${manual.colores.length} color(es) escritos a mano (${resumenDecl(manual.colores, 4)}) que taparán a «${tema}».\n Quítalos con --clean colors (se comentan, con copia .bak), o adapta tu primario: --primary ${manual.primario ?? '<color>'} --mode primary --clean colors`);
595
+ }
498
596
 
597
+ if (!flag('dry-run')) fijarTemaBase(out, tema);
499
598
  if (modo === 'faithful') {
500
599
  console.log(`Tema «${tema}» fiel (sin marca derivada).`);
501
600
  if (flag('dry-run')) return;
502
601
  if (tieneBloque(out)) {
503
- if (flag('update')) console.log(`Marca generada quitada de ${out}.`), quitarBloque(out);
504
- else console.log(`${out} tiene un bloque generado que cambia la paleta del tema. Usa --update para quitarlo.`);
602
+ if (flag('update')) {
603
+ const previa = marcaGenerada(out);
604
+ quitarBloque(out, flag('remember-brand') && previa ? { recordar: { params: previa, tema } } : {});
605
+ console.log(`Marca generada quitada de ${out}.${flag('remember-brand') ? ' Se recuerda para recuperarla al volver a un tema que la admita.' : ''}`);
606
+ } else console.log(`${out} tiene un bloque generado que cambia la paleta del tema. Usa --update para quitarlo.`);
505
607
  } else if (asegurarMarca(out) === 'creado') console.log(`Creado ${out} (vacío: el tema se ve tal cual).`);
506
608
  } else {
507
609
  const primario = parseColor(opt('primary'));
@@ -509,9 +611,10 @@ async function directo() {
509
611
  const acento = opt('accent') ? parseColor(opt('accent')) : undefined;
510
612
  const secundario = opt('secondary') ? parseColor(opt('secondary')) : null;
511
613
  if (opt('secondary') && !secundario) { console.error('Color secundario no válido.'); process.exit(1); }
512
- const res = calcular(modo, tema, primario, { acento, secundario, marcador: !flag('no-marker') });
614
+ const marcador = !flag('no-marker');
615
+ const res = calcular(modo, tema, primario, { acento, secundario, marcador });
513
616
  mostrar(res, tema, hex(primario));
514
- const bloque = bloqueCss(res, { tema, primario: hex(primario), modo });
617
+ const bloque = bloqueCss(res, { tema, primario: hex(primario), modo, secundario: secundario && hex(secundario), acento: acento && hex(acento), marcador });
515
618
  if (flag('dry-run')) { console.log(bloque); return; }
516
619
  if (tieneBloque(out) && !flag('update')) {
517
620
  console.log(`Ya hay un bloque generado en ${out}. Usa --update para reescribirlo.`); return;
@@ -519,8 +622,9 @@ async function directo() {
519
622
  console.log(`Bloque ${escribirBloque(out, bloque)} en ${out}.`);
520
623
  }
521
624
  if (flag('connect')) {
522
- const destino = opt('css') ? resolve(opt('css')) : detectarCssApp() ?? resolve('src/index.css');
625
+ const destino = opt('css') ? resolve(opt('css')) : CSS_APP ?? resolve('src/index.css');
523
626
  console.log(`CSS ${conectarCss(destino, { tema, brandFile: out, motion: flag('animations') })}: ${destino}`);
627
+ for (const l of limpiarImports(destino).lineas) console.log(l);
524
628
  }
525
629
  const paquetes = [...(flag('motion') ? ['motion'] : []), ...(flag('charts') ? ['echarts'] : []), ...(flag('tables') ? ['@tanstack/react-table'] : [])].filter((x) => !yaInstalado(x));
526
630
  if (paquetes.length) {
package/scripts/setup.mjs CHANGED
@@ -3,21 +3,100 @@
3
3
  * el orden correcto (como bloque delimitado, sin tocar lo demás) e instalar paquetes
4
4
  * con el gestor de la app. Lo usa `orbital-ds-init`.
5
5
  */
6
- import { existsSync, readFileSync, writeFileSync } from 'node:fs';
7
- import { dirname, relative, resolve, sep } from 'node:path';
6
+ import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
7
+ import { dirname, join, relative, resolve, sep } from 'node:path';
8
8
  import { spawnSync } from 'node:child_process';
9
9
 
10
10
  export const IMPORTS_INI = '/* orbital-ds:imports:start */';
11
11
  export const IMPORTS_FIN = '/* orbital-ds:imports:end */';
12
12
 
13
- /** CSS principal de la app (el que importa Tailwind), o null. */
13
+ /** Un import de un tema de orbital-ds (o de sus fuentes), en cualquier forma: paquete, dist, node_modules o url(). */
14
+ export const RE_IMPORT_TEMA = /orbital-ds\/(?:dist\/)?themes\/([\w-]+?)(\.fonts)?\.css/;
15
+ const RE_SCOPED = /orbital-ds\/(?:dist\/)?themes\/[\w-]+\.scoped\.css/;
16
+
17
+ /** Ficheros de la app (src/, app/, styles/) con estas extensiones, sin node_modules, dist ni carpetas ocultas. */
18
+ function ficherosApp(cwd, extensiones, profundidad = 4) {
19
+ const res = [];
20
+ const recorrer = (d, n) => {
21
+ if (n < 0 || !existsSync(d)) return;
22
+ for (const e of readdirSync(d, { withFileTypes: true })) {
23
+ if (['node_modules', 'dist', 'build'].includes(e.name) || e.name.startsWith('.')) continue;
24
+ const p = join(d, e.name);
25
+ if (e.isDirectory()) recorrer(p, n - 1);
26
+ else if (extensiones.test(e.name)) res.push(p);
27
+ }
28
+ };
29
+ for (const d of ['src', 'app', 'styles']) recorrer(resolve(cwd, d), profundidad);
30
+ return res;
31
+ }
32
+
33
+ /** Tema que importa un CSS (o null). Los temas con ámbito (*.scoped.css) son del banco de pruebas: no cuentan. */
34
+ export function temaDelCss(cssFile) {
35
+ if (!cssFile || !existsSync(cssFile)) return null;
36
+ for (const m of readFileSync(cssFile, 'utf8').matchAll(new RegExp(RE_IMPORT_TEMA, 'g'))) if (!m[2]) return m[1];
37
+ return null;
38
+ }
39
+
40
+ /**
41
+ * CSS principal de la app, o null. Por orden: el que ya tiene el bloque de imports de orbital-ds, el que
42
+ * importa un tema, el que importa Tailwind (primero los nombres habituales, luego cualquiera de src/ y app/).
43
+ */
14
44
  export function detectarCssApp(cwd = process.cwd()) {
15
- const candidatos = [
16
- 'src/index.css', 'src/styles.css', 'src/globals.css', 'src/app.css', 'src/main.css',
17
- 'app/globals.css', 'app/app.css', 'src/app/globals.css', 'styles/globals.css',
18
- ];
19
- const existentes = candidatos.map((c) => resolve(cwd, c)).filter((f) => existsSync(f));
20
- return existentes.find((f) => /@import\s+['"]tailwindcss['"]/.test(readFileSync(f, 'utf8'))) ?? existentes[0] ?? null;
45
+ const habituales = [
46
+ 'src/index.css', 'src/styles.css', 'src/globals.css', 'src/app.css', 'src/main.css', 'src/styles/app.css',
47
+ 'src/styles/globals.css', 'src/styles/index.css', 'app/globals.css', 'app/app.css', 'app/styles.css',
48
+ 'app/tailwind.css', 'src/app/globals.css', 'styles/globals.css',
49
+ ].map((c) => resolve(cwd, c));
50
+ const todos = [...new Set([...habituales, ...ficherosApp(cwd, /\.css$/)])].filter((f) => existsSync(f) && !/brand[\w.-]*\.css$/.test(f));
51
+ const txt = (f) => readFileSync(f, 'utf8');
52
+ return (
53
+ todos.find((f) => txt(f).includes(IMPORTS_INI)) ??
54
+ todos.find((f) => temaDelCss(f) && /@import\s+['"]tailwindcss['"]/.test(txt(f))) ??
55
+ todos.find((f) => /@import\s+['"]tailwindcss['"]/.test(txt(f))) ??
56
+ todos.find((f) => temaDelCss(f)) ??
57
+ habituales.find((f) => existsSync(f)) ??
58
+ null
59
+ );
60
+ }
61
+
62
+ /** Fichero de marca que importa el CSS de la app (por defecto src/brand.css). */
63
+ export function detectarMarca(cssFile, cwd = process.cwd()) {
64
+ const txt = cssFile && existsSync(cssFile) ? readFileSync(cssFile, 'utf8') : '';
65
+ const m = txt.match(/@import\s+['"](\.{1,2}\/[^'"]*brand[\w.-]*\.css)['"]/);
66
+ return m ? resolve(dirname(cssFile), m[1]) : resolve(cwd, 'src/brand.css');
67
+ }
68
+
69
+ /**
70
+ * Imports de un tema de orbital-ds FUERA del CSS principal: otros CSS, el JS/TS de entrada
71
+ * (`import 'orbital-ds/themes/x.css'`) o el HTML. Con dos temas cargados gana el último y el cambio de
72
+ * tema «no se ve». Los temas con ámbito (*.scoped.css) son del banco de pruebas y no se tocan.
73
+ * Devuelve [{ fichero, linea, texto, tema, sola }]; `sola` = la línea es solo ese import (se puede quitar).
74
+ */
75
+ export function importsDeTemaSueltos(cssPrincipal, cwd = process.cwd()) {
76
+ const res = [];
77
+ for (const f of ficherosApp(cwd, /\.(css|scss|tsx?|jsx?|mjs|html)$/)) {
78
+ if (cssPrincipal && resolve(f) === resolve(cssPrincipal)) continue;
79
+ readFileSync(f, 'utf8').split(/\r?\n/).forEach((l, i) => {
80
+ const m = l.match(RE_IMPORT_TEMA);
81
+ if (!m || RE_SCOPED.test(l)) return;
82
+ const t = l.trim();
83
+ const sola = /^@import\s+(url\()?\s*['"][^'"]+['"]\s*\)?[^;]*;?$/.test(t) || /^import\s+['"][^'"]+['"]\s*;?$/.test(t);
84
+ res.push({ fichero: f, linea: i + 1, texto: t, tema: m[1], sola });
85
+ });
86
+ }
87
+ return res;
88
+ }
89
+
90
+ /** Quita las líneas `sola` de importsDeTemaSueltos(); las demás se dejan (hay que revisarlas a mano). */
91
+ export function quitarImportsSueltos(lista) {
92
+ const porFichero = new Map();
93
+ for (const x of lista.filter((x) => x.sola)) porFichero.set(x.fichero, [...(porFichero.get(x.fichero) ?? []), x.linea]);
94
+ for (const [f, lineas] of porFichero) {
95
+ const actual = readFileSync(f, 'utf8');
96
+ const eol = actual.includes('\r\n') ? '\r\n' : '\n';
97
+ writeFileSync(f, actual.split(/\r?\n/).filter((_, i) => !lineas.includes(i + 1)).join(eol));
98
+ }
99
+ return [...porFichero.keys()];
21
100
  }
22
101
 
23
102
  const rel = (desde, hasta) => {
@@ -60,7 +139,8 @@ export function conectarCss(cssFile, opciones) {
60
139
  .filter((l) => {
61
140
  const t = l.trim();
62
141
  if (/^@import\s+['"](tailwindcss|tw-animate-css)['"]\s*;?$/.test(t)) return false;
63
- if (/^@import\s+['"]orbital-ds\/[^'"]+['"]\s*;?/.test(t)) return false;
142
+ // orbital-ds en cualquier forma (paquete, dist, node_modules o url()), salvo los temas con ámbito del banco de pruebas.
143
+ if (/^@import\s+(url\()?\s*['"][^'"]*orbital-ds\/[^'"]+['"]/.test(t) && !RE_SCOPED.test(t)) return false;
64
144
  if (new RegExp(`^@import\\s+['"][^'"]*${brandBase.replace('.', '\\.')}['"]`).test(t)) return false;
65
145
  if (/^@source\s+['"][^'"]*orbital-ds[^'"]*['"]\s*;?$/.test(t)) return false;
66
146
  return true;