@ultimat3/ui 23.0.0 → 25.0.0

package/src/fake-dom.ts

@@ -1,206 +0,0 @@
-// TEST-ONLY. A DOM small enough to read and real enough to run this package's keyboard code
-// against: focus that a disabled control silently refuses, `document.activeElement`, `contains`,
-// and `querySelectorAll` for the selector grammar these helpers actually pass. Not exported from
-// `index.ts` — the alternative is a DOM dependency, and the bugs it catches are the ones that only
-// exist because nothing ever called `createRovingTabindex` with elements attached.
-
-/** The subset of a selector these helpers use: comma groups of tag + `[attr]` + `:not(...)`. */
-const PART = /\[[^\]]*\]|:not\([^)]*\)/g;
-
-function attrMatches(element: FakeElement, test: string): boolean {
-  const inner = test.slice(1, -1);
-  const eq = inner.indexOf('=');
-  if (eq === -1) return element.getAttribute(inner) !== null;
-  const name = inner.slice(0, eq);
-  const value = inner.slice(eq + 1).replace(/^["']|["']$/g, '');
-  return element.getAttribute(name) === value;
-}
-
-function compoundMatches(element: FakeElement, compound: string): boolean {
-  const tag = compound.split(/[[:]/, 1)[0] ?? '';
-  if (tag !== '' && tag !== element.tagName.toLowerCase()) return false;
-  for (const part of compound.slice(tag.length).match(PART) ?? []) {
-    const ok = part.startsWith(':not(')
-      ? !attrMatches(element, part.slice(5, -1))
-      : attrMatches(element, part);
-    if (!ok) return false;
-  }
-  return true;
-}
-
-/** Listener book shared by the element and the document: registration only, and NO bubbling — a
- * listener on a node never sees an event dispatched somewhere else, which is the whole point of
- * the question `createFocusTrap` gets wrong. */
-class Listeners {
-  readonly listeners = new Map<string, Set<(event: unknown) => void>>();
-
-  addEventListener(type: string, handler: (event: unknown) => void): void {
-    const set = this.listeners.get(type) ?? new Set();
-    set.add(handler);
-    this.listeners.set(type, set);
-  }
-
-  removeEventListener(type: string, handler: (event: unknown) => void): void {
-    this.listeners.get(type)?.delete(handler);
-  }
-
-  dispatch(type: string, event: unknown): void {
-    for (const handler of [...(this.listeners.get(type) ?? [])]) handler(event);
-  }
-}
-
-const NATIVELY_FOCUSABLE = new Set(['BUTTON', 'INPUT', 'SELECT', 'TEXTAREA', 'SUMMARY']);
-const LINK_TAGS = new Set(['A', 'AREA']);
-
-/** An element that behaves like the real thing in the two ways this package's bugs depend on. */
-export class FakeElement extends Listeners {
-  readonly tagName: string;
-  readonly children: FakeElement[] = [];
-  parent: FakeElement | null = null;
-  readonly attrs: Record<string, string>;
-  /** Test assertion surface: how many times focus actually landed here. */
-  focusCount = 0;
-  owner: FakeDocument | null = null;
-
-  constructor(tagName: string, attrs: Record<string, string> = {}) {
-    super();
-    this.tagName = tagName.toUpperCase();
-    this.attrs = { ...attrs };
-  }
-
-  get tabIndex(): number {
-    return Number.parseInt(this.attrs['tabindex'] ?? '-1', 10);
-  }
-
-  set tabIndex(value: number) {
-    this.attrs['tabindex'] = String(value);
-  }
-
-  /**
-   * `Object.hasOwn`, never the read alone: `attrs` is a `{...spread}`, so
-   * `attrs['constructor']` answered with the `Object` FUNCTION where a real
-   * `Element.getAttribute` answers `null` — and `attrMatches` decides presence with
-   * `getAttribute(inner) !== null`, so `querySelectorAll('[constructor]')` matched every
-   * element in the tree. A fake that disagrees with the DOM makes every suite built on it lie.
-   */
-  getAttribute(name: string): string | null {
-    return Object.hasOwn(this.attrs, name) ? (this.attrs[name] ?? null) : null;
-  }
-
-  append(...children: readonly FakeElement[]): FakeElement {
-    for (const child of children) {
-      child.parent = this;
-      this.children.push(child);
-    }
-    return this;
-  }
-
-  /** The bug's mechanism, faithfully: focusing a disabled control does NOTHING and reports nothing.
-   * A tag that is not natively focusable and carries no `tabindex` refuses in exactly the same
-   * silence — `<div>.focus()` is the no-op behind the focus trap's empty-panel fallback. */
-  focus(): void {
-    if (this.getAttribute('disabled') !== null) return;
-    // `tabindex="-1"` IS focusable programmatically; it is only out of the TAB order.
-    const declared = this.getAttribute('tabindex') !== null;
-    if (!declared && !this.nativelyFocusable()) return;
-    this.focusCount += 1;
-    const doc = this.document();
-    if (doc !== null) doc.activeElement = this;
-  }
-
-  contains(node: unknown): boolean {
-    for (let at = node as FakeElement | null; at !== null; at = at.parent) {
-      if (at === this) return true;
-    }
-    return false;
-  }
-
-  descendants(): FakeElement[] {
-    return this.children.flatMap((child) => [child, ...child.descendants()]);
-  }
-
-  /** First match or `null`, exactly as the real one answers — `[0]` on an empty list is not it. */
-  querySelector(selector: string): FakeElement | null {
-    return this.querySelectorAll(selector)[0] ?? null;
-  }
-
-  querySelectorAll(selector: string): FakeElement[] {
-    const groups = selector.split(',').map((one) => one.trim());
-    return this.descendants().filter((el) => groups.some((one) => compoundMatches(el, one)));
-  }
-
-  // `focusableWithin` filters on visibility; nothing in a fake tree is laid out, so everything is
-  // visible — a hidden-element rule would be this harness inventing a fact, not testing one.
-  readonly offsetParent: unknown = null;
-
-  getClientRects(): readonly unknown[] {
-    return [{}];
-  }
-
-  /** Focusable with no `tabindex` at all. `A`/`AREA` only with an `href` — the same condition
-   * `FOCUSABLE_SELECTOR` spells `a[href]`. */
-  private nativelyFocusable(): boolean {
-    if (NATIVELY_FOCUSABLE.has(this.tagName)) return true;
-    return LINK_TAGS.has(this.tagName) && this.getAttribute('href') !== null;
-  }
-
-  private document(): FakeDocument | null {
-    for (let at: FakeElement | null = this; at !== null; at = at.parent) {
-      if (at.owner !== null) return at.owner;
-    }
-    return null;
-  }
-}
-
-export interface FakeKeyboardEvent {
-  readonly key: string;
-  readonly shiftKey: boolean;
-  defaultPrevented: boolean;
-  preventDefault(): void;
-}
-
-export function keydown(key: string, shiftKey = false): FakeKeyboardEvent {
-  return {
-    key,
-    shiftKey,
-    defaultPrevented: false,
-    preventDefault(): void {
-      this.defaultPrevented = true;
-    },
-  };
-}
-
-export class FakeDocument extends Listeners {
-  activeElement: FakeElement | null = null;
-}
-
-export interface InstalledDom {
-  readonly document: FakeDocument;
-  readonly restore: () => void;
-}
-
-/**
- * Publish `document` and `HTMLElement` globally for the duration of one test. Both are needed:
- * `createRovingTabindex` reads `document.activeElement` and narrows it with `instanceof
- * HTMLElement`, so a fake that is not the global class is silently treated as "focus is nowhere".
- * ALWAYS restored — `solid()` decides a render is a server render by `document` being absent, and
- * a leaked one turns every later component test in the process into `X_UI_RUNTIME_MISSING`.
- */
-export function installFakeDom(root: FakeElement): InstalledDom {
-  const document = new FakeDocument();
-  root.owner = document;
-  const hadDocument = 'document' in globalThis;
-  const hadElement = 'HTMLElement' in globalThis;
-  const previousDocument: unknown = Reflect.get(globalThis, 'document');
-  const previousElement: unknown = Reflect.get(globalThis, 'HTMLElement');
-  Object.assign(globalThis, { document, HTMLElement: FakeElement });
-  return {
-    document,
-    restore(): void {
-      if (hadDocument) Object.assign(globalThis, { document: previousDocument });
-      else Reflect.deleteProperty(globalThis, 'document');
-      if (hadElement) Object.assign(globalThis, { HTMLElement: previousElement });
-      else Reflect.deleteProperty(globalThis, 'HTMLElement');
-    },
-  };
-}

package/src/sass-probe.ts

@@ -1,55 +0,0 @@
-// TEST-ONLY. Compiles a stylesheet with the compiler an app's build uses, so a test can read what
-// Sass EMITS — a media query, a `clamp()`, the class list a mixin generates, an `@error` — instead
-// of the source it was written as. Never exported from `index.ts`, like `jsx-probe.ts`.
-
-/** The two members of Sass's API this file calls; the package itself is not a dependency of `ui`. */
-interface SassApi {
-  compileString(source: string, options: { readonly url: URL }): { readonly css: string };
-}
-
-let loading: Promise<SassApi> | undefined;
-
-/**
- * `sass` is `@ultimat3/render`'s dependency — the package that compiles an app's sheets — and `ui`
- * may not import `render` (tier 4, both). Resolved FROM render's directory, so a test compiles with
- * the one compiler at the one version the lockfile pins and `ui` declares no second copy. Only a
- * specifier is read from render; no module of it loads. Lazy, so importing this file has no effect.
- */
-function sassCompiler(): Promise<SassApi> {
-  loading ??= import(
-    Bun.resolveSync('sass', new URL('../../render', import.meta.url).pathname)
-  ) as Promise<SassApi>;
-  return loading;
-}
-
-/** Compile `source` as though it were the file at `path`, so its relative `@use`s resolve. */
-export async function compileScss(source: string, path: string): Promise<string> {
-  const sass = await sassCompiler();
-  return sass.compileString(source, { url: new URL(`file://${path}`) }).css;
-}
-
-/** Compile a stylesheet that exists on disk. */
-export async function compileScssFile(path: string): Promise<string> {
-  return compileScss(await Bun.file(path).text(), path);
-}
-
-/**
- * The `@error` text Sass refused `source` with, or `undefined` when it compiled. A refusal that is
- * not Sass's own — the compiler failing to load — is rethrown: it is not an answer about `source`.
- */
-export async function scssRefusal(source: string, path: string): Promise<string | undefined> {
-  try {
-    await compileScss(source, path);
-  } catch (error) {
-    if (typeof error === 'object' && error !== null && 'sassMessage' in error) {
-      return String(error.sassMessage);
-    }
-    throw error;
-  }
-  return undefined;
-}
-
-/** Every class a compiled stylesheet declares. */
-export function declaredClasses(css: string): ReadonlySet<string> {
-  return new Set([...css.matchAll(/\.([A-Za-z][\w-]*)/g)].map((match) => match[1] as string));
-}

package/src/theme/inline-script.ts

@@ -1,49 +0,0 @@
-// The blocking <head> snippet that kills the flash of wrong theme. Built from the
-// same constants as theme.ts so the two can never disagree. Server/build-only:
-// the hash is computed with Bun's hasher for the CSP header.
-//
-// DEPRECATED `As of 20.2.0`: the framework's boot inlines this script itself, from
-// `@ultimat3/render`'s `themeScript({ fallback })` with `theme.defaultMode` in `app.config.ts` as
-// the fallback, and admits it to the CSP — an app no longer writes either half. This module stays
-// exported for one major so an app that inlined it by hand keeps building; it is removed in 21.
-
-import { runtimeMissingError } from '../errors';
-import { THEME_ATTRIBUTE, THEME_MEDIA_QUERY, THEME_STORAGE_KEY } from './theme';
-
-/**
- * Minified on purpose — this runs before first paint and is inlined into every
- * document. Reads the explicit choice, falls back to the OS, and always stamps
- * `data-theme` so screenshots and Playwright runs are deterministic.
- */
-export const THEME_INLINE_SCRIPT =
-  `try{var d=document.documentElement,` +
-  `s=localStorage.getItem('${THEME_STORAGE_KEY}');` +
-  `d.setAttribute('${THEME_ATTRIBUTE}',` +
-  `s==='light'||s==='dark'?s:` +
-  `matchMedia('${THEME_MEDIA_QUERY}').matches?'dark':'light')}catch(e){}`;
-
-/** The exact tag to inline. No attributes, so the CSP hash stays valid. */
-export function themeInlineScriptTag(): string {
-  return `<script>${THEME_INLINE_SCRIPT}</script>`;
-}
-
-let cachedHash: string | null = null;
-
-/** `sha256-<base64>` for `script-src`. Stable for a given script text. */
-export function themeInlineScriptHash(): string {
-  if (cachedHash !== null) return cachedHash;
-  if (typeof Bun === 'undefined') {
-    throw runtimeMissingError(
-      'Bun.CryptoHasher to hash the theme inline script',
-      'call themeInlineScriptHash() during build or SSR, never in browser code',
-    );
-  }
-  const digest = new Bun.CryptoHasher('sha256').update(THEME_INLINE_SCRIPT).digest('base64');
-  cachedHash = `sha256-${digest}`;
-  return cachedHash;
-}
-
-/** Quoted CSP source expression, ready to concatenate into a `script-src`. */
-export function themeInlineScriptCspSource(): string {
-  return `'${themeInlineScriptHash()}'`;
-}