@omega.js/desktop 0.50.0 → 0.51.0

package/dist/vendor/devkit/argv.js

@@ -0,0 +1,118 @@
+/**
+ * The ONE argv parse behind every OMEGA CLI: node's `util.parseArgs` wearing
+ * the yargs conveniences the bins and their commands still read
+ * ([#920](https://github.com/Omega-JS-Stack/omega/issues/920)). yargs is gone;
+ * this is what replaced it, in one place so the five CLIs can never drift.
+ *
+ * THE VALUE RULE, which is yargs' own: a flag named in `booleans` never takes a
+ * value, and every OTHER flag takes the next token as its value when that token
+ * exists and does not start with `-`, else it is `true`. `--flag=value` always
+ * wins. So a CLI declares only what is value-LESS, and a flag nobody declared
+ * still carries its value: the brand root forwards `omega test --filter foo` to
+ * a target whose parse has never heard of `--filter`, and CI really runs
+ * `sign-windows --in release --out release/signed`.
+ *
+ * What the builtin does NOT do, and what this adds back:
+ *   1. THE VALUE RULE above. To `parseArgs` an undeclared flag is boolean, so
+ *      the value of a space-separated `--only hosting` would fall through to
+ *      `_`. The line is PRE-SCANNED to build the options map instead: every
+ *      flag whose occurrence takes a value is declared a string, and parseArgs
+ *      still does all the tokenizing.
+ *   2. CAMEL TWINS. `parseArgs` gives `--dry-run` exactly one key, `dry-run`.
+ *      Dozens of reads say `options.dryRun` (the manager alone has ~100) with
+ *      no kebab fallback, and the manager's buildForwardedFlags skips a camel
+ *      key whose kebab original exists. So every kebab flag lands under BOTH
+ *      spellings, exactly as yargs minted them.
+ *   3. NEGATION. `parseArgs` reads `--no-secrets` as a flag NAMED `no-secrets`.
+ *      Every consumer tests the positive key against false (`argv.https !==
+ *      false`, the deploy precheck's `secrets: false`), so `--no-<x>` sets
+ *      `<x>` to false, never takes a value, and never survives under its own
+ *      name.
+ *   4. REPEATS. A repeated flag overwrites unless it is declared `multiple`,
+ *      and an array of one is not what a single occurrence meant: the backend's
+ *      `--where` accumulates into an array and one clause stays a string.
+ *
+ * Positionals come back at `_`, the key every consumer already reads. The
+ * router owns `--help`/`--version`, so nothing here is reserved.
+ *
+ * Stdlib-only on purpose: a vendored module must not push a dependency onto
+ * its hosts.
+ */
+
+const { parseArgs } = require('node:util');
+
+/** `signed-dir` becomes `signedDir` (the twin yargs minted beside every kebab key). */
+function camelCase(name) {
+  return name.replace(/-([a-z0-9])/g, (match, character) => character.toUpperCase());
+}
+
+/**
+ * The options map for THIS line: the declarations plus every flag the value
+ * rule says carries a value. A clustered short (`-abc`) declares nothing and
+ * stays boolean, and so does a `--no-<x>` negation.
+ */
+function declarationsFor(args, booleans, multiples) {
+  const options = {};
+
+  for (const name of booleans) options[name] = { type: 'boolean' };
+  for (const name of multiples) options[name] = { type: 'string', multiple: true };
+
+  for (let index = 0; index < args.length; index++) {
+    const token = args[index];
+    if (token === '--') break;
+
+    const flag = /^--([^-=][^=]*)(=)?/.exec(token) || /^-([^-])$/.exec(token);
+    if (!flag) continue;
+
+    const name = flag[1];
+    if (options[name]) continue;
+
+    // A negation is value-LESS (rule 3), so the token behind it is a positional
+    // of its own and never the negation's value.
+    if (name.startsWith('no-')) {
+      options[name] = { type: 'boolean' };
+      continue;
+    }
+
+    const next = args[index + 1];
+    if (flag[2] || (next !== undefined && !next.startsWith('-'))) {
+      options[name] = { type: 'string' };
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Parse a CLI argv tail into the yargs-shaped options object the CLIs read.
+ *
+ * @param {string[]} args - The argv tail (`process.argv.slice(2)`).
+ * @param {object} [declarations]
+ * @param {string[]} [declarations.booleans] - Value-less flags (`--extended`), the only list a CLI owes
+ * @param {string[]} [declarations.multiples] - Value flags that accumulate when repeated (`--where`).
+ * @returns {object} `{ _: positionals, ...flags }`, each kebab flag under both spellings
+ */
+function parseArgv(args, declarations = {}) {
+  const { booleans = [], multiples = [] } = declarations;
+  const options = declarationsFor(args, booleans, multiples);
+
+  const { values, positionals } = parseArgs({ args, options, strict: false, allowPositionals: true });
+  const parsed = { _: positionals };
+
+  for (const [key, raw] of Object.entries(values)) {
+    // A repeated declaration always answers an array; one occurrence is one value.
+    const value = Array.isArray(raw) && raw.length === 1 ? raw[0] : raw;
+
+    // Negation names the POSITIVE flag. Last spelling wins, as it did under
+    // yargs: `--secrets --no-secrets` ends false.
+    const negated = key.startsWith('no-');
+    const name = negated ? key.slice(3) : key;
+
+    parsed[name] = negated ? false : value;
+    if (name.includes('-')) parsed[camelCase(name)] = parsed[name];
+  }
+
+  return parsed;
+}
+
+module.exports = { parseArgv };

package/dist/vendor/devkit/attach-log-file.js

@@ -22,6 +22,11 @@
 // That is what keeps an inner tee's detach from stealing (and truncating) the outer tee's
 // file, the way a shared singleton did.
 //
+// Two attaches on ONE tee stack the same way: a second attach of a DIFFERENT path pushes a
+// layer on top of the first instead of replacing it, so a verb that runs another verb in
+// process (`omega test` running `omega deploy`) keeps teeing both files. Detach order is
+// LIFO, and the module-level `detach()` pops the newest layer.
+//
 // Skipped in CI: a runner has its own log capture and wants no logs/ left in the workspace.
 // `attachInCI: true` opts out of that skip, for a sink whose file is the POINT rather than
 // workspace debris (the signing box's own runner log, which a CI job is exactly when it
@@ -51,8 +56,10 @@ function isCI(env) {
 
 // Factory — each call returns an independent tee with its own closure state.
 function createTee() {
-  let activePath = null;
-  let activeDetach = null;
+  // One entry per live attach on this tee, oldest first. A layer restores the writers it
+  // captured, so detaching in LIFO order (the only order a nested run produces) unwinds
+  // the patches exactly as they went on.
+  const layers = [];
   let warned = false;
 
   function attach(filePath, options) {
@@ -63,10 +70,10 @@ function createTee() {
 
     const abs = path.resolve(filePath);
 
-    // Already teeing this exact file — do not patch a second time (that would write
-    // every line twice).
-    if (activePath === abs) { return activeDetach; }
-    if (activeDetach) { activeDetach(); }
+    // Already teeing this exact file, so do not patch a second time (that would write every
+    // line twice, and reopen the file truncated under the live layer).
+    const live = layers.find((layer) => layer.path === abs);
+    if (live) { return live.detach; }
 
     let fd;
     try {
@@ -125,21 +132,22 @@ function createTee() {
       process.off('exit', closeFd);
       closeFd();
 
-      if (activeDetach === detach) {
-        activePath = null;
-        activeDetach = null;
-      }
+      const index = layers.indexOf(layer);
+      if (index !== -1) { layers.splice(index, 1); }
     }
 
-    activePath = abs;
-    activeDetach = detach;
+    const layer = { path: abs, detach };
+    layers.push(layer);
 
     return detach;
   }
 
   return {
     attach,
-    detach: () => { if (activeDetach) { activeDetach(); } },
+    detach: () => {
+      const newest = layers[layers.length - 1];
+      if (newest) { newest.detach(); }
+    },
   };
 }
 

package/dist/vendor/devkit/brand-tokens.js

@@ -0,0 +1,278 @@
+/**
+ * Brand accent ramp — derives the accent token family from ONE brand color
+ * (C3/D6: `brand.color` drives the accent everywhere via CSS custom
+ * properties; the static token sheet's neutral placeholder stands when the
+ * brand has no usable color).
+ *
+ * Pure math, dependency-free: hex → RGB → HSL round-trips plus WCAG
+ * relative luminance for the on-accent ink pick. Every output value is
+ * regenerated from parsed numbers, so nothing from config reaches the
+ * emitted <style> block verbatim.
+ *
+ * ONE home for three surfaces ([#912](https://github.com/Omega-JS-Stack/omega/issues/912)):
+ * @omega.js/web inlines the ramp into <head> after its bundles, and
+ * @omega.js/desktop and @omega.js/extension write `renderBrandScss()` below to
+ * a generated `_brand.scss` their sass tasks compile. Same hex in, same ramp
+ * out, on every target.
+ */
+
+const INK_DARK = '#111213';
+const INK_LIGHT = '#ffffff';
+
+// WCAG contrast-vs-white beats contrast-vs-black below this luminance
+const INK_LUMINANCE_THRESHOLD = 0.1791;
+
+// Accents darker than this lightness brighten on hover instead of darkening
+const HOVER_LIGHTEN_THRESHOLD = 0.25;
+
+// Dark-mode variant: accents at/above this lightness are already legible on
+// charcoal and pass through; darker ones lift into the floor..ceil band.
+const DARK_KEEP_THRESHOLD = 0.66;
+const DARK_LIGHTNESS_FLOOR = 0.55;
+const DARK_LIGHTNESS_CEIL = 0.78;
+
+/**
+ * Parse a 3- or 6-digit hex color.
+ * @param {*} value - candidate color
+ * @returns {{ r: number, g: number, b: number }|null} channels 0-255, or null
+ */
+function parseHex(value) {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const match = value.trim().match(/^#?([0-9a-f]{3}|[0-9a-f]{6})$/i);
+  if (!match) {
+    return null;
+  }
+
+  let hex = match[1].toLowerCase();
+  if (hex.length === 3) {
+    hex = hex.split('').map((c) => c + c).join('');
+  }
+
+  return {
+    r: parseInt(hex.slice(0, 2), 16),
+    g: parseInt(hex.slice(2, 4), 16),
+    b: parseInt(hex.slice(4, 6), 16),
+  };
+}
+
+/**
+ * WCAG 2.x relative luminance.
+ * @param {{ r: number, g: number, b: number }} rgb - channels 0-255
+ * @returns {number} 0 (black) to 1 (white)
+ */
+function relativeLuminance({ r, g, b }) {
+  const linearize = (channel) => {
+    const c = channel / 255;
+    return c <= 0.03928 ? c / 12.92 : (((c + 0.055) / 1.055) ** 2.4);
+  };
+  return (0.2126 * linearize(r)) + (0.7152 * linearize(g)) + (0.0722 * linearize(b));
+}
+
+/**
+ * RGB (0-255) → HSL (h 0-360, s/l 0-1).
+ */
+function rgbToHsl({ r, g, b }) {
+  const rn = r / 255;
+  const gn = g / 255;
+  const bn = b / 255;
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const l = (max + min) / 2;
+
+  if (max === min) {
+    return { h: 0, s: 0, l };
+  }
+
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === rn) {
+    h = ((gn - bn) / d) + (gn < bn ? 6 : 0);
+  } else if (max === gn) {
+    h = ((bn - rn) / d) + 2;
+  } else {
+    h = ((rn - gn) / d) + 4;
+  }
+
+  return { h: h * 60, s, l };
+}
+
+/**
+ * HSL (h 0-360, s/l 0-1) → RGB (0-255).
+ */
+function hslToRgb({ h, s, l }) {
+  if (s === 0) {
+    const v = Math.round(l * 255);
+    return { r: v, g: v, b: v };
+  }
+
+  const hueToChannel = (p, q, t) => {
+    let tn = t;
+    if (tn < 0) tn += 1;
+    if (tn > 1) tn -= 1;
+    if (tn < 1 / 6) return p + ((q - p) * 6 * tn);
+    if (tn < 1 / 2) return q;
+    if (tn < 2 / 3) return p + ((q - p) * ((2 / 3) - tn) * 6);
+    return p;
+  };
+
+  const q = l < 0.5 ? l * (1 + s) : l + s - (l * s);
+  const p = (2 * l) - q;
+  const hn = h / 360;
+
+  return {
+    r: Math.round(hueToChannel(p, q, hn + (1 / 3)) * 255),
+    g: Math.round(hueToChannel(p, q, hn) * 255),
+    b: Math.round(hueToChannel(p, q, hn - (1 / 3)) * 255),
+  };
+}
+
+/**
+ * RGB → #rrggbb.
+ */
+function toHex({ r, g, b }) {
+  const pair = (v) => v.toString(16).padStart(2, '0');
+  return `#${pair(r)}${pair(g)}${pair(b)}`;
+}
+
+/**
+ * Shift an accent's lightness for hover/active states — darker accents
+ * brighten, everything else deepens, clamped to [0, 1].
+ * @param {{ h: number, s: number, l: number }} hsl - base accent
+ * @param {number} amount - lightness delta (positive magnitude)
+ * @returns {string} #rrggbb
+ */
+function shiftLightness(hsl, amount) {
+  const direction = hsl.l < HOVER_LIGHTEN_THRESHOLD ? 1 : -1;
+  const l = Math.min(1, Math.max(0, hsl.l + (direction * amount)));
+  return toHex(hslToRgb({ ...hsl, l }));
+}
+
+/**
+ * Compose one accent ramp from resolved channels.
+ * @param {{ r: number, g: number, b: number }} rgb - accent channels
+ * @param {{ h: number, s: number, l: number }} hsl - same accent in HSL
+ * @param {number} subtleAlpha - alpha for the subtle wash (mode-specific)
+ * @returns {object} { accent, accentHover, accentActive, accentSubtle, accentInk, accentRing }
+ */
+function composeRamp(rgb, hsl, subtleAlpha) {
+  const luminance = relativeLuminance(rgb);
+
+  return {
+    accent: toHex(rgb),
+    accentHover: shiftLightness(hsl, 0.07),
+    accentActive: shiftLightness(hsl, 0.11),
+    accentSubtle: `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${subtleAlpha})`,
+    accentInk: luminance > INK_LUMINANCE_THRESHOLD ? INK_DARK : INK_LIGHT,
+    accentRing: `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.35)`,
+  };
+}
+
+/**
+ * Compose the accent token families from a brand color: the light ramp plus
+ * a dark-mode variant (darker brand colors lift so they stay legible on the
+ * charcoal ground — the classy v2 per-mode accent).
+ * @param {string} color - brand color (#rgb or #rrggbb)
+ * @returns {object|null} ramps for the head emitter, or null when unusable:
+ *   { accent, accentHover, accentActive, accentSubtle, accentInk, accentRing,
+ *     dark: { …same shape… } }
+ */
+function composeBrandTokens(color) {
+  const rgb = parseHex(color);
+  if (!rgb) {
+    return null;
+  }
+
+  const hsl = rgbToHsl(rgb);
+  const darkHsl = hsl.l >= DARK_KEEP_THRESHOLD
+    ? hsl
+    : { ...hsl, l: Math.min(Math.max(hsl.l + 0.1, DARK_LIGHTNESS_FLOOR), DARK_LIGHTNESS_CEIL) };
+  const darkRgb = hslToRgb(darkHsl);
+
+  return {
+    ...composeRamp(rgb, hsl, 0.12),
+    dark: composeRamp(darkRgb, darkHsl, 0.16),
+  };
+}
+
+/**
+ * The ONE accent default. `brand.color` unset (or unusable) lands here, and the
+ * classy theme's `$primary: … !default` carries the same hex purely as the Sass
+ * mechanism that lets this partial win: the VALUE is decided here.
+ */
+const DEFAULT_BRAND_COLOR = '#2563EB';
+
+/** The six properties, in the order head.html emits them on web. */
+const RAMP_PROPERTIES = [
+  ['--omega-accent', 'accent'],
+  ['--omega-accent-hover', 'accentHover'],
+  ['--omega-accent-active', 'accentActive'],
+  ['--omega-accent-subtle', 'accentSubtle'],
+  ['--omega-accent-ink', 'accentInk'],
+  ['--omega-accent-ring', 'accentRing'],
+];
+
+/**
+ * One `selector { … }` block of the ramp, indented for the mixin body.
+ * @param {string} selector - the rule's selector
+ * @param {object} ramp - one ramp (the light half, or `.dark`)
+ * @param {number} depth - indent depth in 2-space steps
+ * @returns {string} the rule text
+ */
+function renderRampBlock(selector, ramp, depth) {
+  const pad = '  '.repeat(depth);
+  const declarations = RAMP_PROPERTIES.map(([property, key]) => `${pad}  ${property}: ${ramp[key]};`);
+
+  return [`${pad}${selector} {`, ...declarations, `${pad}}`].join('\n');
+}
+
+/**
+ * Render the generated `_brand.scss` a target's sass task writes beside its
+ * compile: `$primary` for the compile-time accent Bootstrap derives from, plus
+ * a `ramp` mixin carrying the runtime `--omega-accent` family under the SAME
+ * three stamps the token sheet uses (bare `:root`, the OS preference, the
+ * explicit `data-bs-theme` stamp both ways).
+ *
+ * The css rides a MIXIN rather than the file root on purpose: a used module's
+ * css is emitted at its LOAD position, which is ahead of the framework module's
+ * token sheet and theme, so a root-level rule here would lose the cascade to
+ * the very placeholders it replaces. The consumer's `@include brand.ramp;` puts
+ * it after both.
+ *
+ * @param {object|null} tokens - composeBrandTokens() output, or null for the default
+ * @returns {string} the partial's full text
+ */
+function renderBrandScss(tokens) {
+  const ramp = tokens || composeBrandTokens(DEFAULT_BRAND_COLOR);
+
+  return `// AUTO-GENERATED by the sass task from \`brand.color\` in omega.json5.
+// Every build rewrites it: edit the config, not this file.
+//
+// \`$primary\` is the compile-time accent (Bootstrap's color ramp compiles from
+// it) and \`ramp\` is the runtime --omega-accent family, the same light and dark
+// ramps @omega.js/web inlines into <head>. Include the mixin AFTER the
+// framework module so the ramp wins the cascade over the token sheet's
+// placeholders.
+
+$primary: ${ramp.accent};
+
+@mixin ramp {
+${renderRampBlock(':root', ramp, 1)}
+
+  // The OS preference carries when no explicit choice is stamped...
+  @media (prefers-color-scheme: dark) {
+${renderRampBlock(':root', ramp.dark, 2)}
+  }
+
+  // ...and the appearance stamp beats the OS in BOTH directions.
+${renderRampBlock(":root[data-bs-theme='dark']", ramp.dark, 1)}
+
+${renderRampBlock(":root[data-bs-theme='light']", ramp, 1)}
+}
+`;
+}
+
+module.exports = { composeBrandTokens, parseHex, relativeLuminance, renderBrandScss, DEFAULT_BRAND_COLOR };