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/AGENTS.md +5 -0
- package/README.md +5 -1
- package/dist/styles.css +1 -0
- package/dist/themes/liquid.css +502 -0
- package/dist/themes/liquid.fonts.css +7 -0
- package/dist/themes/liquid.guide.md +82 -0
- package/dist/themes/liquid.meta.json +134 -0
- package/dist/themes/liquid.scoped.css +502 -0
- package/dist/themes/liquid.tokens.json +47 -0
- package/dist/ui/switch.js +1 -1
- package/package.json +2 -1
- package/scripts/brand-file.mjs +221 -0
- package/scripts/cli.mjs +111 -29
- package/scripts/init.mjs +176 -72
- package/scripts/setup.mjs +90 -10
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
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
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
|
-
|
|
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 =
|
|
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:
|
|
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
|
-
|
|
363
|
-
|
|
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) :
|
|
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
|
-
|
|
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
|
-
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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'))
|
|
504
|
-
|
|
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
|
|
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')) :
|
|
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
|
-
/**
|
|
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
|
|
16
|
-
'src/index.css', 'src/styles.css', 'src/globals.css', 'src/app.css', 'src/main.css',
|
|
17
|
-
'
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
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
|
-
|
|
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;
|