@mono-lit/helper 0.0.1 → 0.0.3

package/dist/src/composables/mono-skeleton.d.ts

@@ -1,107 +1,108 @@
+//#region src/composables/mono-skeleton.d.ts
 /** phantom-ui's options, camelCase (applied to the wrapper as kebab-case attributes). */
 export interface MonoPhantomProps {
-    /** `shimmer` (default) | `pulse` | `breathe` | `solid`. */
-    animation?: 'shimmer' | 'pulse' | 'breathe' | 'solid' | (string & {});
-    /** `skeleton` (default, hides the content) | `overlay` (dims it and sweeps). */
-    mode?: 'skeleton' | 'overlay' | (string & {});
-    shimmerDirection?: 'ltr' | 'rtl' | 'ttb' | 'btt' | (string & {});
-    /** Sweep colour. Unset = the mono theme's (`--mono-skeleton-color`). */
-    shimmerColor?: string;
-    /** Block colour. Unset = the mono theme's (`--mono-skeleton-bg`). */
-    backgroundColor?: string;
-    /** Animation cycle, seconds (default 1.5). */
-    duration?: number;
-    /** Delay between blocks, seconds. */
-    stagger?: number;
-    /** Fade-out when loading ends, seconds. */
-    reveal?: number;
-    /** Repeat the measured row set N times (table placeholders). */
-    count?: number;
-    /** Gap between repeated rows, px. */
-    countGap?: number;
-    /** Radius for flat elements, px (default 4). */
-    fallbackRadius?: number;
-    /** Screen-reader announcement (default "Loading"). */
-    loadingLabel?: string;
-    /** Measure inside open shadow roots of slotted components. */
-    pierceShadow?: boolean;
-    /** Outline the measured blocks. */
-    debug?: boolean;
+  /** `shimmer` (default) | `pulse` | `breathe` | `solid`. */
+  animation?: 'shimmer' | 'pulse' | 'breathe' | 'solid' | (string & {});
+  /** `skeleton` (default, hides the content) | `overlay` (dims it and sweeps). */
+  mode?: 'skeleton' | 'overlay' | (string & {});
+  shimmerDirection?: 'ltr' | 'rtl' | 'ttb' | 'btt' | (string & {});
+  /** Sweep colour. Unset = the mono theme's (`--mono-skeleton-color`). */
+  shimmerColor?: string;
+  /** Block colour. Unset = the mono theme's (`--mono-skeleton-bg`). */
+  backgroundColor?: string;
+  /** Animation cycle, seconds (default 1.5). */
+  duration?: number;
+  /** Delay between blocks, seconds. */
+  stagger?: number;
+  /** Fade-out when loading ends, seconds. */
+  reveal?: number;
+  /** Repeat the measured row set N times (table placeholders). */
+  count?: number;
+  /** Gap between repeated rows, px. */
+  countGap?: number;
+  /** Radius for flat elements, px (default 4). */
+  fallbackRadius?: number;
+  /** Screen-reader announcement (default "Loading"). */
+  loadingLabel?: string;
+  /** Measure inside open shadow roots of slotted components. */
+  pierceShadow?: boolean;
+  /** Outline the measured blocks. */
+  debug?: boolean;
 }
 /** The object form of `pending`: `active` plays the boolean's part (omitted = auto). */
 export type MonoPendingOptions = {
-    active?: boolean;
+  active?: boolean;
 } & Partial<MonoPhantomProps>;
 /** `pending` — `true` / `false`, or an object with phantom-ui options. `undefined` = auto. */
 export type MonoPending = boolean | MonoPendingOptions;
 /** `createMonoUI({ skeleton: {...} })` — global phantom defaults + the SSR flag. */
 export interface MonoSkeletonDefaults extends Partial<MonoPhantomProps> {
-    /**
-     * Whether the app renders on the server. Decides the AUTO default of light elements:
-     * `true` → pending on first connect, `false` → never pending unless asked. The Nuxt
-     * module sets it from `nuxt.options.ssr`; unset, a Nuxt payload marker is sniffed.
-     */
-    ssr?: boolean;
-    /**
-     * Safety net for an automatic pending that never gets its "loaded" signal: released
-     * after this many ms (default 15000; `0` disables).
-     */
-    maxWait?: number;
+  /**
+   * Whether the app renders on the server. Decides the AUTO default of light elements:
+   * `true` → pending on first connect, `false` → never pending unless asked. The Nuxt
+   * module sets it from `nuxt.options.ssr`; unset, a Nuxt payload marker is sniffed.
+   */
+  ssr?: boolean;
+  /**
+   * Safety net for an automatic pending that never gets its "loaded" signal: released
+   * after this many ms (default 15000; `0` disables).
+   */
+  maxWait?: number;
 }
 export interface MonoSkeletonStatus {
-    /** `phantom-ui` is defined in this realm (and the skeleton is not disabled). */
-    active: boolean;
-    /** The configured SSR flag (`null` = not set, the sniffed value is used). */
-    ssr: boolean | null;
-    /** Elements whose first render happened BEFORE activation (no skeleton on that first paint). */
-    createdBeforeActive: number;
-    createdBeforeActiveTags: string[];
+  /** `phantom-ui` is defined in this realm (and the skeleton is not disabled). */
+  active: boolean;
+  /** The configured SSR flag (`null` = not set, the sniffed value is used). */
+  ssr: boolean | null;
+  /** Elements whose first render happened BEFORE activation (no skeleton on that first paint). */
+  createdBeforeActive: number;
+  createdBeforeActiveTags: string[];
 }
 /** Which "loaded" signal an element's AUTO pending waits for. */
 export type MonoPendingAuto = 'render' | 'data' | 'never';
 /** Statics a Core may declare to tune the automatic behaviour. */
 export interface MonoPendingStatics {
-    /**
-     * `'render'` (default) — released in the element's first update, before first paint.
-     * `'data'` — released when `_monoPendingReady()` first returns true (re-checked on
-     * every update; the Cores request one on each controller / source notify).
-     * `'never'` — never automatic (overlays like modal / drawer); manual still works.
-     */
-    monoPendingAuto?: MonoPendingAuto;
-    /**
-     * `'wrap'` (default) — the mixin wraps `render()` in `<phantom-ui>`.
-     * `'custom'` — the element draws its own placeholder from `monoPendingActive(this)`
-     * (e.g. `mono-table-loading`); the mixin only resolves the state.
-     */
-    monoPendingMode?: 'wrap' | 'custom';
-    /**
-     * How the element's own pending is drawn. `'phantom'` (default) — phantom-ui measures the
-     * content (a wrapper, one re-render per flip). `'css'` — only the `mono-pending` host
-     * attribute, i.e. the CSS-only block: no wrapper, no re-render, right for small elements
-     * whose measured skeleton would be one bar anyway (the table helpers). Render-driven
-     * elements held by a loading page draw through phantom like everything else; the CSS lane
-     * is their fallback while phantom-ui is not (yet) defined.
-     */
-    monoPendingDraw?: 'phantom' | 'css';
+  /**
+   * `'render'` (default) — released in the element's first update, before first paint.
+   * `'data'` — released when `_monoPendingReady()` first returns true (re-checked on
+   * every update; the Cores request one on each controller / source notify).
+   * `'never'` — never automatic (overlays like modal / drawer); manual still works.
+   */
+  monoPendingAuto?: MonoPendingAuto;
+  /**
+   * `'wrap'` (default) — the mixin wraps `render()` in `<phantom-ui>`.
+   * `'custom'` — the element draws its own placeholder from `monoPendingActive(this)`
+   * (e.g. `mono-table-loading`); the mixin only resolves the state.
+   */
+  monoPendingMode?: 'wrap' | 'custom';
+  /**
+   * How the element's own pending is drawn. `'phantom'` (default) — phantom-ui measures the
+   * content (a wrapper, one re-render per flip). `'css'` — only the `mono-pending` host
+   * attribute, i.e. the CSS-only block: no wrapper, no re-render, right for small elements
+   * whose measured skeleton would be one bar anyway (the table helpers). Render-driven
+   * elements held by a loading page draw through phantom like everything else; the CSS lane
+   * is their fallback while phantom-ui is not (yet) defined.
+   */
+  monoPendingDraw?: 'phantom' | 'css';
 }
 /** A render-driven element held by the page (internal). */
 export interface MonoHeldElement {
-    _monoReleaseHeld(): void;
+  _monoReleaseHeld(): void;
 }
 interface MonoSkeletonState {
-    active: boolean;
-    disabled: boolean;
-    ssr: boolean | null;
-    ssrSniffed: boolean | null;
-    defaults: MonoSkeletonDefaults;
-    watching: boolean;
-    createdBeforeActive: number;
-    createdBeforeActiveTags: string[];
-    warnedLate: boolean;
-    /** Data-driven elements still waiting for their first load (the page is "loading"). */
-    waiting: Set<object>;
-    /** Render-driven elements held pending until `waiting` empties. */
-    holders: Set<MonoHeldElement>;
+  active: boolean;
+  disabled: boolean;
+  ssr: boolean | null;
+  ssrSniffed: boolean | null;
+  defaults: MonoSkeletonDefaults;
+  watching: boolean;
+  createdBeforeActive: number;
+  createdBeforeActiveTags: string[];
+  warnedLate: boolean;
+  /** Data-driven elements still waiting for their first load (the page is "loading"). */
+  waiting: Set<object>;
+  /** Render-driven elements held pending until `waiting` empties. */
+  holders: Set<MonoHeldElement>;
 }
 /** Per-element slots the Cores can read without depending on the mixin's class shape. */
 declare const TAG_DEFAULT: unique symbol;
@@ -139,8 +140,8 @@ export declare function pendingChanged(next: unknown, prev: unknown): boolean;
  * A real boolean is accepted too (what a server renderer hands over).
  */
 export declare const pendingConverter: {
-    fromAttribute(value: unknown): MonoPending | undefined;
-    toAttribute(): null;
+  fromAttribute(value: unknown): MonoPending | undefined;
+  toAttribute(): null;
 };
 /**
  * Register the `pending` property on a registered element class. Called by the mono
@@ -170,19 +171,19 @@ export declare function monoPhantomOptions(el: object): Readonly<Record<string,
 export declare function monoApplyPhantomOptions(el: object, target: Element | null | undefined): void;
 /** @internal */
 export declare const monoSkeletonInternals: {
-    readonly hasDom: boolean;
-    readonly isActive: typeof isActive;
-    readonly state: MonoSkeletonState;
-    readonly slots: {
-        readonly TAG_DEFAULT: typeof TAG_DEFAULT;
-        readonly PENDING_ACTIVE: typeof PENDING_ACTIVE;
-        readonly PENDING_GRACE: typeof PENDING_GRACE;
-        readonly PENDING_PHANTOM: typeof PENDING_PHANTOM;
-    };
-    readonly activeOf: typeof activeOf;
-    readonly phantomOf: typeof phantomOf;
-    readonly PHANTOM_TAG: "phantom-ui";
-    readonly DEFAULT_MAX_WAIT: 15000;
+  readonly hasDom: boolean;
+  readonly isActive: typeof isActive;
+  readonly state: MonoSkeletonState;
+  readonly slots: {
+    readonly TAG_DEFAULT: typeof TAG_DEFAULT;
+    readonly PENDING_ACTIVE: typeof PENDING_ACTIVE;
+    readonly PENDING_GRACE: typeof PENDING_GRACE;
+    readonly PENDING_PHANTOM: typeof PENDING_PHANTOM;
+  };
+  readonly activeOf: typeof activeOf;
+  readonly phantomOf: typeof phantomOf;
+  readonly PHANTOM_TAG: "phantom-ui";
+  readonly DEFAULT_MAX_WAIT: 15000;
 };
 /** The `<phantom-ui>` wrapper the skeleton mixin renders around an element's content. */
 export declare function isMonoSkeletonWrapper(node: Node | null | undefined): boolean;
@@ -190,4 +191,5 @@ export declare function isMonoSkeletonWrapper(node: Node | null | undefined): bo
 export declare function monoHostChildNodes(host: Node): Node[];
 /** `Array.from(host.children)` minus the skeleton wrapper. */
 export declare function monoHostChildren(host: Element): Element[];
-export {};
+//#endregion
+export {};

package/dist/src/composables/mono-ui.d.ts

@@ -1,35 +1,33 @@
-import { MonoSkeletonDefaults } from './mono-skeleton';
+import { MonoSkeletonDefaults } from "./mono-skeleton.js";
+//#region src/composables/mono-ui.d.ts
 /**
  * Tag → props map for typed configs. `scripts/gen-vue-types.mjs` augments it in
  * the published types (`'mono-button': ButtonProps`, …); it is empty in source.
  */
-export interface MonoUIComponents {
-}
-type KnownConfig = {
-    [K in keyof MonoUIComponents]?: Partial<MonoUIComponents[K]>;
-};
+export interface MonoUIComponents {}
+type KnownConfig = { [K in keyof MonoUIComponents]?: Partial<MonoUIComponents[K]>; };
 /**
  * Per-component default props. Keys are tags (`mono-button`); props are camelCase or kebab-case.
  * The reserved `skeleton` key holds the global defaults of the automatic skeleton
  * (`pending`, see ./mono-skeleton.ts) and its `ssr` flag; `false` disables it.
  */
 export type MonoUIConfig = KnownConfig & {
-    skeleton?: MonoSkeletonDefaults | false;
+  skeleton?: MonoSkeletonDefaults | false;
 } & {
-    [tag: `mono-${string}`]: Record<string, unknown> | undefined;
+  [tag: `mono-${string}`]: Record<string, unknown> | undefined;
 };
 export interface MonoUI {
-    readonly config: Readonly<MonoUIConfig>;
-    /** Vue plugin hook — a no-op; the call already applied the config. */
-    install(app?: unknown): void;
+  readonly config: Readonly<MonoUIConfig>;
+  /** Vue plugin hook — a no-op; the call already applied the config. */
+  install(app?: unknown): void;
 }
 export interface MonoUIStatus {
-    /** `createMonoUI` has been called (and not reset). */
-    configured: boolean;
-    /** Mono elements constructed BEFORE the current config was set — they kept built-in defaults. */
-    createdBefore: number;
-    /** Their tags, first occurrence order. */
-    createdBeforeTags: string[];
+  /** `createMonoUI` has been called (and not reset). */
+  configured: boolean;
+  /** Mono elements constructed BEFORE the current config was set — they kept built-in defaults. */
+  createdBefore: number;
+  /** Their tags, first occurrence order. */
+  createdBeforeTags: string[];
 }
 /**
  * Set the app-wide default props. Call once, first — usually in `main.ts`:
@@ -55,4 +53,5 @@ export declare function resetMonoUI(): void;
  * @internal
  */
 export declare function applyMonoUIDefaults(el: HTMLElement, tag: string): void;
-export {};
+//#endregion
+export {};

package/dist/src/composables/notifier.d.ts

@@ -1,26 +1,27 @@
+//#region src/composables/notifier.d.ts
 /** A subscriber callback. */
 export type MonoNotifyFn = () => void;
 export interface MonoNotifier {
-    /** Register a subscriber; returns its unsubscribe handle. */
-    subscribe(cb: MonoNotifyFn): () => void;
-    /** Schedule a coalesced notification. */
-    notify(): void;
-    /** Drop every subscriber (controller `dispose`). */
-    clear(): void;
-    /** How many subscribers are attached — handy for tests / diagnostics. */
-    readonly size: number;
+  /** Register a subscriber; returns its unsubscribe handle. */
+  subscribe(cb: MonoNotifyFn): () => void;
+  /** Schedule a coalesced notification. */
+  notify(): void;
+  /** Drop every subscriber (controller `dispose`). */
+  clear(): void;
+  /** How many subscribers are attached — handy for tests / diagnostics. */
+  readonly size: number;
 }
 export interface MonoNotifierOptions {
-    /**
-     * Runs immediately before the subscribers, inside the same flush. Use it to
-     * recompute derived state that subscribers are about to read (e.g. the grid
-     * refreshes its merged element props and writes its `state` snapshot here).
-     */
-    onFlush?: () => void;
-    /** Names the controller in the runaway-loop error (`'form'`, `'grid'` …). */
-    name?: string;
-    /** Extra context for that error — e.g. the form keys that notified last. Called only on a trip. */
-    detail?: () => string;
+  /**
+   * Runs immediately before the subscribers, inside the same flush. Use it to
+   * recompute derived state that subscribers are about to read (e.g. the grid
+   * refreshes its merged element props and writes its `state` snapshot here).
+   */
+  onFlush?: () => void;
+  /** Names the controller in the runaway-loop error (`'form'`, `'grid'` …). */
+  name?: string;
+  /** Extra context for that error — e.g. the form keys that notified last. Called only on a trip. */
+  detail?: () => string;
 }
 /**
  * Flushes allowed back-to-back without the event loop getting a turn. Real work never comes close:
@@ -44,3 +45,4 @@ export declare const MONO_NOTIFY_RUNAWAY_LIMIT = 200;
  * implementation means one place to fix if the scheduling ever needs to change.
  */
 export declare function createNotifier(options?: MonoNotifierOptions): MonoNotifier;
+//#endregion