@clusterenvision/ui-framework 1.0.0

package/dist/browser-Dx4oKf5e.d.ts

@@ -0,0 +1,354 @@
+import './component-wTxZ2BPD.js';
+import { S as SignalAccessor, e as SignalsInspectorSnapshot } from './browser-signals-07qodpYT.js';
+import { b as RuntimeErrorInfo, l as RouteHandlerResult, a as RouteMatch, g as RouteDefinition, R as Router } from './router-B9kms5XQ.js';
+import './ai-assistant-Db002XYC.js';
+import './runtime/adapters/angular.js';
+import './runtime/adapters/react.js';
+import './runtime/adapters/vue.js';
+import './runtime/components/ai-summary-card.js';
+
+type ValidationMessage = string;
+interface ValidationContext<T = unknown> {
+    name: string;
+    value: T;
+    values: Record<string, unknown>;
+    touched: boolean;
+}
+type Validator<T> = (value: T, context: ValidationContext<T>) => ValidationMessage | null | Promise<ValidationMessage | null>;
+interface FieldValidationState {
+    name: string;
+    valid: boolean;
+    errors: string[];
+}
+interface FieldControl<T> {
+    name: string;
+    value: SignalAccessor<T>;
+    errors: SignalAccessor<string[]>;
+    touched: SignalAccessor<boolean>;
+    setValue(value: T): void;
+    markTouched(): void;
+    validate(): Promise<boolean>;
+    validateWithState(): Promise<FieldValidationState>;
+}
+interface FieldArrayControl<T> extends FieldControl<T[]> {
+    append(value: T): void;
+    insert(index: number, value: T): void;
+    remove(index: number): void;
+    swap(indexA: number, indexB: number): void;
+    move(fromIndex: number, toIndex: number): void;
+}
+type FormErrorLeaf = string[];
+type FormErrorValue = FormErrorLeaf | FormErrorMap | FormErrorValue[];
+type FormErrorMap = Record<string, FormErrorValue>;
+interface FormValidationResult {
+    valid: boolean;
+    errors: FormErrorMap;
+    fields: Record<string, FieldValidationState>;
+}
+interface RegisterOptions<T> {
+    initialValue: T;
+    validators?: Validator<T>[];
+}
+interface FormController {
+    register<T>(name: string, options: RegisterOptions<T>): FieldControl<T>;
+    registerArray<T>(name: string, options: RegisterOptions<T[]>): FieldArrayControl<T>;
+    handleSubmit<T extends Event = Event>(handler: (values: Record<string, unknown>, event?: T) => void | Promise<void>): (event?: T) => Promise<void>;
+    validate(): Promise<FormValidationResult>;
+    validateFields(names: string[]): Promise<FormValidationResult>;
+    values(): Record<string, unknown>;
+    errors(): FormErrorMap;
+}
+declare function createFormController(): FormController;
+interface FormWizardStep {
+    id: string;
+    title?: string;
+    description?: string;
+    fields?: string[];
+    validate?: (form: FormController) => boolean | Promise<boolean>;
+}
+interface FormWizardController {
+    steps: FormWizardStep[];
+    currentIndex: SignalAccessor<number>;
+    currentStep: SignalAccessor<FormWizardStep>;
+    isFirst: SignalAccessor<boolean>;
+    isLast: SignalAccessor<boolean>;
+    goTo(step: number | string): void;
+    next(): Promise<boolean>;
+    previous(): void;
+    validateCurrent(): Promise<boolean>;
+    reset(step?: number | string): void;
+}
+declare function createFormWizard(form: FormController, steps: FormWizardStep[], initialStep?: number | string): FormWizardController;
+
+type ResourceKey = string | number | boolean | null | undefined | ResourceKey[] | Record<string, ResourceKey>;
+
+type ResourceStatus = 'idle' | 'loading' | 'success' | 'error';
+
+type ResourceErrorType = 'network' | 'timeout' | 'abort' | 'server' | 'client' | 'unknown';
+
+interface ClassifiedError extends Error {
+  type: ResourceErrorType;
+  retryable: boolean;
+  statusCode?: number;
+}
+
+interface ResourceState<T = unknown> {
+  status: ResourceStatus;
+  data?: T;
+  error?: Error;
+  updatedAt?: number;
+}
+
+interface ResourceCache {
+  read(key: string): ResourceState<unknown> | undefined;
+  write(key: string, state: ResourceState<unknown>): void;
+  delete(key: string): void;
+  clear(): void;
+  keys(): string[];
+}
+
+interface ResourceContext {
+  signal?: AbortSignal;
+  force?: boolean;
+}
+
+type ResourceFetcher<T> = (context: ResourceContext) => T | Promise<T>;
+
+interface ResourceOptions<T> {
+  cache?: ResourceCache;
+  enabled?: boolean;
+  initialData?: T;
+  staleTimeMs?: number;
+  cacheTimeMs?: number;
+  refetchOnStale?: boolean;
+  retry?: boolean | number | ((attempt: number, error: ClassifiedError) => boolean);
+  retryDelayMs?: number | ((attempt: number) => number);
+  maxRetries?: number;
+  onSuccess?: (data: T) => void;
+  onError?: (error: Error) => void;
+  onSettled?: (data: T | undefined, error: Error | undefined) => void;
+}
+
+interface OptimisticUpdateOptions<T> {
+  optimisticData: T;
+  rollbackOnError?: boolean;
+  onRollback?: (previousData: T | undefined) => void;
+}
+
+interface Resource<T> {
+  key: SignalAccessor<string>;
+  state: SignalAccessor<ResourceState<T>>;
+  isStale(): boolean;
+  load(context?: ResourceContext): Promise<ResourceState<T>>;
+  refresh(context?: ResourceContext): Promise<ResourceState<T>>;
+  mutate(mutator: (data: T | undefined) => T | Promise<T>, options?: OptimisticUpdateOptions<T>): Promise<ResourceState<T>>;
+  setData(data: T): void;
+  setError(error: Error): void;
+  clear(): void;
+}
+
+declare function createResourceCache(): ResourceCache;
+declare function getResourceCache(): ResourceCache;
+declare function normalizeResourceKey(key: ResourceKey): string;
+declare function invalidateResource(key: ResourceKey, cache?: ResourceCache): void;
+declare function isResourceStale(state: ResourceState<unknown>, staleTimeMs?: number): boolean;
+declare function isResourceExpired(state: ResourceState<unknown>, cacheTimeMs?: number): boolean;
+declare function classifyError(error: unknown): ClassifiedError;
+declare function calculateRetryDelay(attempt: number, baseDelayMs?: number): number;
+declare function createResource<T>(
+  key: ResourceKey,
+  fetcher: ResourceFetcher<T>,
+  options?: ResourceOptions<T>,
+): Resource<T>;
+
+interface RuntimeErrorReport {
+    error: Error;
+    info: RuntimeErrorInfo;
+    handled: boolean;
+    boundaryId?: string;
+}
+interface RuntimeErrorReporter {
+    name: string;
+    report: (report: RuntimeErrorReport) => void | Promise<void>;
+}
+declare function registerRuntimeErrorReporters(next: RuntimeErrorReporter[]): void;
+declare function addRuntimeErrorReporter(reporter: RuntimeErrorReporter): void;
+declare function clearRuntimeErrorReporters(): void;
+declare function getRuntimeErrorReporters(): readonly RuntimeErrorReporter[];
+declare function emitRuntimeErrorReport(report: RuntimeErrorReport): void;
+
+type RouteDataCacheEntry = RouteHandlerResult;
+
+interface DiagnosticsSnapshot {
+  reports: RuntimeErrorReport[];
+  routeData: Record<string, RouteDataCacheEntry>;
+  resources: Record<string, ResourceState<unknown>>;
+}
+
+interface RuntimeDiagnosticsStore {
+  reports: SignalAccessor<RuntimeErrorReport[]>;
+  attach(): void;
+  detach(): void;
+  clearReports(): void;
+  getSnapshot(): DiagnosticsSnapshot;
+  getRouteDataSnapshot(): Record<string, RouteDataCacheEntry>;
+  getResourceSnapshot(): Record<string, ResourceState<unknown>>;
+}
+
+interface DiagnosticsOptions {
+  maxReports?: number;
+  reporterName?: string;
+}
+
+declare function createRuntimeDiagnosticsStore(options?: DiagnosticsOptions): RuntimeDiagnosticsStore;
+
+interface RouteInspectorNode {
+  id: string;
+  path: string;
+  fullPath: string;
+  hasLoader: boolean;
+  hasAction: boolean;
+  hasGuards: boolean;
+  children: RouteInspectorNode[];
+  isActive: boolean;
+}
+
+interface RouterInspectorSnapshot {
+  currentPath: string;
+  currentMatch: RouteMatch | null;
+  tree: RouteInspectorNode[];
+  routeData: Record<string, RouteDataCacheEntry>;
+}
+
+interface RouterInspector {
+  tree: SignalAccessor<RouteInspectorNode[]>;
+  currentPath: SignalAccessor<string>;
+  currentMatch: SignalAccessor<RouteMatch | null>;
+  getSnapshot(): RouterInspectorSnapshot;
+  getRouteDataSnapshot(): Record<string, RouteDataCacheEntry>;
+}
+
+declare function buildRouteTree(routes: RouteDefinition[], parentPath?: string): RouteInspectorNode[];
+declare function createRouterInspector(router: Router, routes: RouteDefinition[]): RouterInspector;
+
+interface DevtoolsDashboardOptions {
+  className?: string;
+  routerInspector?: RouterInspector;
+  diagnosticsStore?: RuntimeDiagnosticsStore;
+  hydrationReport?: RuntimeErrorReport;
+  signalsSnapshot?: SignalsInspectorSnapshot;
+  showRefresh?: boolean;
+  showSummary?: boolean;
+  showHydrationTemplate?: boolean;
+  enableSummaryToggle?: boolean;
+  enablePanelsToggle?: boolean;
+  enableCompactToggle?: boolean;
+  enableThemeToggle?: boolean;
+  enableCopyDiagnostics?: boolean;
+  enableClearDiagnostics?: boolean;
+  showRouterSummary?: boolean;
+  enableExportDiagnostics?: boolean;
+  enableResetPanels?: boolean;
+  compact?: boolean;
+  theme?: 'default' | 'soft';
+}
+
+declare function createDevtoolsDashboard(options?: DevtoolsDashboardOptions): HTMLElement;
+
+interface RouterInspectorPanelOptions {
+  className?: string;
+  showRouteData?: boolean;
+}
+
+declare function createRouterInspectorPanel(
+  inspector: RouterInspector,
+  options?: RouterInspectorPanelOptions,
+): HTMLElement;
+
+interface SignalsInspectorStore {
+  snapshot: SignalAccessor<SignalsInspectorSnapshot>;
+  refresh(): SignalsInspectorSnapshot;
+  clear(): void;
+}
+
+interface SignalsGraphNode {
+  id: string;
+  type: 'signal' | 'effect';
+  label: string;
+}
+
+interface SignalsGraphEdge {
+  from: string;
+  to: string;
+  type: 'tracks';
+}
+
+interface SignalsGraph {
+  nodes: SignalsGraphNode[];
+  edges: SignalsGraphEdge[];
+}
+
+declare function createSignalsInspector(): SignalsInspectorStore;
+declare function buildSignalsGraph(snapshot: SignalsInspectorSnapshot): SignalsGraph;
+
+interface SignalsInspectorPanelOptions {
+  className?: string;
+  snapshot?: SignalsInspectorSnapshot;
+}
+
+declare function createSignalsInspectorPanel(options?: SignalsInspectorPanelOptions): HTMLElement;
+
+interface HydrationMismatchSummary {
+  total: number;
+  byTemplateId: Record<string, number>;
+  byComponentName: Record<string, number>;
+  byReason: Record<string, number>;
+}
+
+declare function getHydrationReports(reports: RuntimeErrorReport[]): RuntimeErrorReport[];
+declare function buildHydrationSummary(reports: RuntimeErrorReport[]): HydrationMismatchSummary;
+
+interface HydrationDomPayload {
+  expectedDom?: string;
+  receivedDom?: string;
+}
+
+interface HydrationDomDiff {
+  hasMismatch: boolean;
+  firstMismatchIndex: number;
+  expectedLength: number;
+  receivedLength: number;
+  expectedContext: string;
+  receivedContext: string;
+}
+
+interface HydrationReplaySession {
+  payload: HydrationDomPayload;
+  diff: HydrationDomDiff | null;
+  applyExpected(target: Node): void;
+  applyReceived(target: Node): void;
+  clear(target: Node): void;
+}
+
+declare function getHydrationDomPayload(report: RuntimeErrorReport): HydrationDomPayload;
+declare function buildHydrationDomDiff(
+  expectedDom: string | undefined,
+  receivedDom: string | undefined,
+  contextRadius?: number,
+): HydrationDomDiff;
+declare function createHydrationReplaySession(
+  report: RuntimeErrorReport,
+  options?: { contextRadius?: number },
+): HydrationReplaySession;
+
+interface HydrationReplayPanelOptions {
+  contextRadius?: number;
+  className?: string;
+}
+
+declare function createHydrationReplayPanel(
+  report: RuntimeErrorReport,
+  options?: HydrationReplayPanelOptions,
+): HTMLElement;
+
+export { createDevtoolsDashboard as $, type RouterInspectorPanelOptions as A, type RouterInspectorSnapshot as B, type ClassifiedError as C, type DevtoolsDashboardOptions as D, type RuntimeDiagnosticsStore as E, type FieldArrayControl as F, type RuntimeErrorReport as G, type HydrationDomDiff as H, type RuntimeErrorReporter as I, type SignalsGraphEdge as J, type SignalsGraphNode as K, type SignalsInspectorPanelOptions as L, type SignalsInspectorStore as M, type ValidationMessage as N, type OptimisticUpdateOptions as O, type Validator as P, addRuntimeErrorReporter as Q, type RegisterOptions as R, type SignalsGraph as S, buildHydrationDomDiff as T, buildHydrationSummary as U, type ValidationContext as V, buildRouteTree as W, buildSignalsGraph as X, calculateRetryDelay as Y, classifyError as Z, clearRuntimeErrorReporters as _, type DiagnosticsOptions as a, createFormController as a0, createFormWizard as a1, createHydrationReplayPanel as a2, createHydrationReplaySession as a3, createResource as a4, createResourceCache as a5, createRouterInspector as a6, createRouterInspectorPanel as a7, createRuntimeDiagnosticsStore as a8, createSignalsInspector as a9, createSignalsInspectorPanel as aa, emitRuntimeErrorReport as ab, getHydrationDomPayload as ac, getHydrationReports as ad, getResourceCache as ae, getRuntimeErrorReporters as af, invalidateResource as ag, isResourceExpired as ah, isResourceStale as ai, normalizeResourceKey as aj, registerRuntimeErrorReporters as ak, type DiagnosticsSnapshot as b, type FieldControl as c, type FieldValidationState as d, type FormController as e, type FormErrorLeaf as f, type FormErrorMap as g, type FormErrorValue as h, type FormValidationResult as i, type FormWizardController as j, type FormWizardStep as k, type HydrationDomPayload as l, type HydrationMismatchSummary as m, type HydrationReplayPanelOptions as n, type HydrationReplaySession as o, type Resource as p, type ResourceCache as q, type ResourceContext as r, type ResourceErrorType as s, type ResourceFetcher as t, type ResourceKey as u, type ResourceOptions as v, type ResourceState as w, type ResourceStatus as x, type RouteInspectorNode as y, type RouterInspector as z };

package/dist/browser-signals-07qodpYT.d.cts

@@ -0,0 +1,66 @@
+type Dispose = () => void;
+declare class Signal<T> {
+    private value;
+    private subscribers;
+    private readonly id;
+    private readonly traceSink?;
+    constructor(initial: T);
+    read(): T;
+    write(next: T): void;
+    update(updater: (current: T) => T): void;
+    subscribe(listener: (value: T) => void): Dispose;
+    private notify;
+    detach(effect: Effect): void;
+}
+declare class Effect {
+    private fn;
+    private teardown;
+    private trackedSignals;
+    private scheduled;
+    private readonly scheduler;
+    private readonly id;
+    private readonly name;
+    private readonly attributes?;
+    private readonly traceSink?;
+    constructor(fn: () => void, options?: EffectOptions);
+    run(): void;
+    track(signal: Signal<unknown>): void;
+    schedule(): void;
+    flush: () => void;
+    cleanup(): void;
+    setTeardown(cb: Dispose): void;
+}
+declare function batch<T>(fn: () => T): T;
+type SignalAccessor<T> = (() => T) & {
+    set(value: T): void;
+    update(recipe: (current: T) => T): void;
+};
+declare function signal<T>(initial: T): SignalAccessor<T>;
+declare function computed<T>(producer: () => T): SignalAccessor<T>;
+interface EffectOptions {
+    name?: string;
+    scheduler?: (effect: Effect) => void;
+    attributes?: Record<string, unknown>;
+}
+declare function effect(fn: () => void, options?: EffectOptions): Dispose;
+interface SignalSnapshot {
+    id: string;
+    value: unknown;
+    subscribers: number;
+}
+interface EffectSnapshot {
+    id: string;
+    name: string;
+    scheduled: boolean;
+    trackedSignals: number;
+    trackedSignalIds: string[];
+    attributes?: Record<string, unknown>;
+}
+interface SignalsInspectorSnapshot {
+    signals: SignalSnapshot[];
+    effects: EffectSnapshot[];
+}
+declare function getSignalsInspectorSnapshot(): SignalsInspectorSnapshot;
+declare function clearSignalsInspectorRegistry(): void;
+
+export { type Dispose as D, Effect as E, type SignalAccessor as S, type EffectOptions as a, type EffectSnapshot as b, Signal as c, type SignalSnapshot as d, type SignalsInspectorSnapshot as e, batch as f, clearSignalsInspectorRegistry as g, computed as h, effect as i, getSignalsInspectorSnapshot as j, signal as s };

package/dist/browser-signals-07qodpYT.d.ts

@@ -0,0 +1,66 @@
+type Dispose = () => void;
+declare class Signal<T> {
+    private value;
+    private subscribers;
+    private readonly id;
+    private readonly traceSink?;
+    constructor(initial: T);
+    read(): T;
+    write(next: T): void;
+    update(updater: (current: T) => T): void;
+    subscribe(listener: (value: T) => void): Dispose;
+    private notify;
+    detach(effect: Effect): void;
+}
+declare class Effect {
+    private fn;
+    private teardown;
+    private trackedSignals;
+    private scheduled;
+    private readonly scheduler;
+    private readonly id;
+    private readonly name;
+    private readonly attributes?;
+    private readonly traceSink?;
+    constructor(fn: () => void, options?: EffectOptions);
+    run(): void;
+    track(signal: Signal<unknown>): void;
+    schedule(): void;
+    flush: () => void;
+    cleanup(): void;
+    setTeardown(cb: Dispose): void;
+}
+declare function batch<T>(fn: () => T): T;
+type SignalAccessor<T> = (() => T) & {
+    set(value: T): void;
+    update(recipe: (current: T) => T): void;
+};
+declare function signal<T>(initial: T): SignalAccessor<T>;
+declare function computed<T>(producer: () => T): SignalAccessor<T>;
+interface EffectOptions {
+    name?: string;
+    scheduler?: (effect: Effect) => void;
+    attributes?: Record<string, unknown>;
+}
+declare function effect(fn: () => void, options?: EffectOptions): Dispose;
+interface SignalSnapshot {
+    id: string;
+    value: unknown;
+    subscribers: number;
+}
+interface EffectSnapshot {
+    id: string;
+    name: string;
+    scheduled: boolean;
+    trackedSignals: number;
+    trackedSignalIds: string[];
+    attributes?: Record<string, unknown>;
+}
+interface SignalsInspectorSnapshot {
+    signals: SignalSnapshot[];
+    effects: EffectSnapshot[];
+}
+declare function getSignalsInspectorSnapshot(): SignalsInspectorSnapshot;
+declare function clearSignalsInspectorRegistry(): void;
+
+export { type Dispose as D, Effect as E, type SignalAccessor as S, type EffectOptions as a, type EffectSnapshot as b, Signal as c, type SignalSnapshot as d, type SignalsInspectorSnapshot as e, batch as f, clearSignalsInspectorRegistry as g, computed as h, effect as i, getSignalsInspectorSnapshot as j, signal as s };

package/dist/browser-signals.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunkVHUXNDW2_cjs = require('./chunk-VHUXNDW2.cjs');
+
+
+
+Object.defineProperty(exports, "Effect", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.Effect; }
+});
+Object.defineProperty(exports, "Signal", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.Signal; }
+});
+Object.defineProperty(exports, "batch", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.batch; }
+});
+Object.defineProperty(exports, "computed", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.computed; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.effect; }
+});
+Object.defineProperty(exports, "signal", {
+  enumerable: true,
+  get: function () { return chunkVHUXNDW2_cjs.signal; }
+});
+//# sourceMappingURL=browser-signals.cjs.map
+//# sourceMappingURL=browser-signals.cjs.map

package/dist/browser-signals.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"browser-signals.cjs"}

package/dist/browser-signals.d.cts

@@ -0,0 +1 @@
+export { D as Dispose, E as Effect, a as EffectOptions, c as Signal, S as SignalAccessor, f as batch, h as computed, i as effect, s as signal } from './browser-signals-07qodpYT.cjs';

package/dist/browser-signals.d.ts

@@ -0,0 +1 @@
+export { D as Dispose, E as Effect, a as EffectOptions, c as Signal, S as SignalAccessor, f as batch, h as computed, i as effect, s as signal } from './browser-signals-07qodpYT.js';

package/dist/browser-signals.js

@@ -0,0 +1,3 @@
+export { Effect, Signal, batch, computed, effect, signal } from './chunk-PFBEIFVS.js';
+//# sourceMappingURL=browser-signals.js.map
+//# sourceMappingURL=browser-signals.js.map

package/dist/browser-signals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"browser-signals.js"}