sibujs 1.2.0 → 1.3.0

package/dist/chunk-WZSPOOER.js

@@ -0,0 +1,84 @@
+import {
+  drainNotificationQueue,
+  notifySubscribers,
+  queueSignalNotification,
+  recordDependency
+} from "./chunk-ZD6OAMTH.js";
+import {
+  isDev
+} from "./chunk-5X6PP2UK.js";
+
+// src/reactivity/batch.ts
+var batchDepth = 0;
+var pendingSignals = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      flushBatch();
+    }
+  }
+}
+function enqueueBatchedSignal(signal2) {
+  if (batchDepth === 0) return false;
+  pendingSignals.add(signal2);
+  return true;
+}
+function isBatching() {
+  return batchDepth > 0;
+}
+function flushBatch() {
+  for (const signal2 of pendingSignals) {
+    queueSignalNotification(signal2);
+  }
+  pendingSignals.clear();
+  drainNotificationQueue();
+}
+
+// src/core/signals/signal.ts
+var _g = globalThis;
+var _isDev = isDev();
+function signal(initial, options) {
+  const state = { value: initial };
+  const debugName = _isDev ? options?.name : void 0;
+  const equalsFn = options?.equals;
+  if (debugName) {
+    state.__name = debugName;
+  }
+  function get() {
+    recordDependency(state);
+    return state.value;
+  }
+  get.__signal = state;
+  if (debugName) get.__name = debugName;
+  function set(next) {
+    const newValue = typeof next === "function" ? next(state.value) : next;
+    if (equalsFn ? equalsFn(state.value, newValue) : Object.is(newValue, state.value)) return;
+    if (_isDev) {
+      const oldValue = state.value;
+      state.value = newValue;
+      const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+      if (hook) hook.emit("signal:update", { signal: state, name: debugName, oldValue, newValue });
+    } else {
+      state.value = newValue;
+    }
+    if (!enqueueBatchedSignal(state)) {
+      notifySubscribers(state);
+    }
+  }
+  if (_isDev) {
+    const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (hook) hook.emit("signal:create", { signal: state, name: debugName, getter: get, initial });
+  }
+  return [get, set];
+}
+
+export {
+  batch,
+  enqueueBatchedSignal,
+  isBatching,
+  signal
+};

package/dist/chunk-YT6HQ6AM.js

@@ -0,0 +1,14 @@
+// src/core/rendering/createId.ts
+var idCounter = 0;
+function createId(prefix = "sibu") {
+  idCounter++;
+  return `${prefix}-${idCounter}`;
+}
+function __resetIdCounter() {
+  idCounter = 0;
+}
+
+export {
+  createId,
+  __resetIdCounter
+};

package/dist/chunk-ZD6OAMTH.js

@@ -0,0 +1,277 @@
+import {
+  devWarn,
+  isDev
+} from "./chunk-5X6PP2UK.js";
+
+// src/reactivity/track.ts
+var _isDev = isDev();
+var subscriberStack = new Array(32);
+var stackCapacity = 32;
+var stackTop = -1;
+var currentSubscriber = null;
+var signalSubscribers = /* @__PURE__ */ new WeakMap();
+var SUBS = "__s";
+var notifyDepth = 0;
+var pendingQueue = [];
+var pendingSet = /* @__PURE__ */ new Set();
+function safeInvoke(sub) {
+  try {
+    sub();
+  } catch (err) {
+    if (_isDev) devWarn(`Subscriber threw during notification: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+var suspendDepth = 0;
+var trackingSuspended = false;
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  ++stackTop;
+  if (stackTop >= stackCapacity) {
+    stackCapacity *= 2;
+    subscriberStack.length = stackCapacity;
+  }
+  subscriberStack[stackTop] = subscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+  }
+  return () => cleanup(subscriber);
+}
+function suspendTracking() {
+  if (suspendDepth === 0) {
+    ++stackTop;
+    if (stackTop >= stackCapacity) {
+      stackCapacity *= 2;
+      subscriberStack.length = stackCapacity;
+    }
+    subscriberStack[stackTop] = null;
+    currentSubscriber = null;
+    trackingSuspended = true;
+  }
+  suspendDepth++;
+}
+function resumeTracking() {
+  suspendDepth--;
+  if (suspendDepth === 0) {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+    trackingSuspended = false;
+  }
+}
+function untracked(fn) {
+  suspendTracking();
+  try {
+    return fn();
+  } finally {
+    resumeTracking();
+  }
+}
+function recordDependency(signal) {
+  if (!currentSubscriber) return;
+  const sub = currentSubscriber;
+  if (sub._dep === signal) return;
+  const deps = sub._deps;
+  if (deps) {
+    if (deps.has(signal)) return;
+    deps.add(signal);
+  } else if (sub._dep !== void 0) {
+    const set = /* @__PURE__ */ new Set();
+    set.add(sub._dep);
+    set.add(signal);
+    sub._deps = set;
+    sub._dep = void 0;
+  } else {
+    sub._dep = signal;
+  }
+  let subs = signal[SUBS];
+  if (!subs) {
+    subs = /* @__PURE__ */ new Set();
+    signalSubscribers.set(signal, subs);
+    signal[SUBS] = subs;
+  }
+  subs.add(currentSubscriber);
+  if (subs.size === 1) {
+    signal.__f = currentSubscriber;
+  } else if (signal.__f !== void 0) {
+    signal.__f = void 0;
+  }
+}
+function queueSignalNotification(signal) {
+  const subs = signal[SUBS];
+  if (!subs) return;
+  for (const sub of subs) {
+    if (sub._c) {
+      propagateDirty(sub);
+    } else if (!pendingSet.has(sub)) {
+      pendingSet.add(sub);
+      pendingQueue.push(sub);
+    }
+  }
+}
+function drainNotificationQueue() {
+  if (notifyDepth > 0) return;
+  notifyDepth++;
+  try {
+    let i = 0;
+    while (i < pendingQueue.length) {
+      safeInvoke(pendingQueue[i]);
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function propagateDirty(sub) {
+  sub();
+  let sig = sub._sig;
+  while (sig) {
+    const first = sig.__f;
+    if (first) {
+      if (first._c) {
+        const nSig = first._sig;
+        nSig._d = true;
+        sig = nSig;
+        continue;
+      }
+      if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      break;
+    }
+    const subs = sig[SUBS];
+    if (!subs) break;
+    let nextSig;
+    for (const s of subs) {
+      if (s._c) {
+        s();
+        const nSig = s._sig;
+        if (nSig && !nextSig) {
+          nextSig = nSig;
+        } else if (nSig) {
+          propagateDirty(s);
+        }
+      } else if (!pendingSet.has(s)) {
+        pendingSet.add(s);
+        pendingQueue.push(s);
+      }
+    }
+    sig = nextSig;
+  }
+}
+function notifySubscribers(signal) {
+  const first = signal.__f;
+  if (first) {
+    if (notifyDepth > 0) {
+      if (first._c) {
+        propagateDirty(first);
+      } else if (!pendingSet.has(first)) {
+        pendingSet.add(first);
+        pendingQueue.push(first);
+      }
+      return;
+    }
+    notifyDepth++;
+    try {
+      if (first._c) {
+        propagateDirty(first);
+      } else {
+        safeInvoke(first);
+      }
+      let i = 0;
+      while (i < pendingQueue.length) {
+        safeInvoke(pendingQueue[i]);
+        i++;
+      }
+    } finally {
+      pendingQueue.length = 0;
+      pendingSet.clear();
+      notifyDepth--;
+    }
+    return;
+  }
+  const subs = signal[SUBS];
+  if (!subs || subs.size === 0) return;
+  if (notifyDepth > 0) {
+    for (const sub of subs) {
+      if (sub._c) {
+        propagateDirty(sub);
+      } else if (!pendingSet.has(sub)) {
+        pendingSet.add(sub);
+        pendingQueue.push(sub);
+      }
+    }
+    return;
+  }
+  notifyDepth++;
+  try {
+    let directCount = 0;
+    for (const sub of subs) {
+      pendingQueue[directCount++] = sub;
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (pendingQueue[i2]._c) {
+        propagateDirty(pendingQueue[i2]);
+      }
+    }
+    for (let i2 = 0; i2 < directCount; i2++) {
+      if (!pendingQueue[i2]._c) {
+        if (!pendingSet.has(pendingQueue[i2])) {
+          safeInvoke(pendingQueue[i2]);
+        }
+      }
+    }
+    let i = directCount;
+    while (i < pendingQueue.length) {
+      safeInvoke(pendingQueue[i]);
+      i++;
+    }
+  } finally {
+    pendingQueue.length = 0;
+    pendingSet.clear();
+    notifyDepth--;
+  }
+}
+function cleanup(subscriber) {
+  const sub = subscriber;
+  const singleDep = sub._dep;
+  if (singleDep !== void 0) {
+    const subs = singleDep[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (singleDep.__f === subscriber) {
+        singleDep.__f = void 0;
+      }
+    }
+    sub._dep = void 0;
+    return;
+  }
+  const deps = sub._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal of deps) {
+    const subs = signal[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal.__f === subscriber) {
+        signal.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+export {
+  trackingSuspended,
+  track,
+  untracked,
+  recordDependency,
+  queueSignalNotification,
+  drainNotificationQueue,
+  notifySubscribers
+};

package/dist/contracts-DDrwxvJ-.d.cts

@@ -0,0 +1,245 @@
+/**
+ * Higher-order component utilities for SibuJS.
+ * These functions wrap or compose components to add behavior.
+ */
+type Component<P = unknown> = (props: P) => HTMLElement;
+/**
+ * Wraps a component with additional behavior that runs before/after rendering.
+ *
+ * @param WrappedComponent The component to wrap
+ * @param wrapper Function that receives the component and its props, returns enhanced element
+ * @returns A new component function
+ *
+ * @example
+ * ```ts
+ * const WithLogging = withWrapper(MyComponent, (Comp, props) => {
+ *   console.log("Rendering with props:", props);
+ *   return Comp(props);
+ * });
+ * ```
+ */
+declare function withWrapper<P>(WrappedComponent: Component<P>, wrapper: (component: Component<P>, props: P) => HTMLElement): Component<P>;
+/**
+ * Adds default props to a component. Missing props are filled from defaults.
+ *
+ * @param component The component to wrap
+ * @param defaults Default prop values
+ * @returns A new component with defaults applied
+ *
+ * @example
+ * ```ts
+ * const Button = withDefaults(RawButton, { type: "button", disabled: false });
+ * Button({ nodes: "Click" }); // type="button", disabled=false automatically
+ * ```
+ */
+declare function withDefaults<P extends Record<string, unknown>>(component: Component<P>, defaults: Partial<P>): Component<Partial<P>>;
+/**
+ * Composes multiple HOC wrappers into a single wrapper.
+ * Applied from right to left (like function composition).
+ *
+ * @param wrappers Array of HOC functions
+ * @returns A function that applies all wrappers to a component
+ *
+ * @example
+ * ```ts
+ * const enhance = compose(withAuth, withLogging, withTheme);
+ * const EnhancedPage = enhance(Page);
+ * ```
+ */
+declare function compose(...wrappers: Array<(component: Component) => Component>): (component: Component) => Component;
+
+/**
+ * composable wraps a setup function to create reusable stateful logic.
+ * Similar to Vue 3 composables — encapsulates reactive state and methods.
+ */
+declare function composable<T>(setup: () => T): () => T;
+/**
+ * RenderProp implements the render-prop pattern.
+ * The render function receives data and returns DOM nodes.
+ */
+declare function RenderProp<T>(props: {
+    data: () => T;
+    render: (data: T) => HTMLElement;
+}): HTMLElement;
+/**
+ * withBoundary creates an isolated component boundary for debugging.
+ * Wraps component output in a named container with error isolation.
+ */
+declare function withBoundary(name: string, component: (props?: unknown) => HTMLElement): (props?: unknown) => HTMLElement;
+/**
+ * Slot pattern — provides named slots for component composition.
+ */
+declare function createSlots(slots: Record<string, () => HTMLElement | HTMLElement[] | null>): {
+    renderSlot: (name: string, fallback?: () => HTMLElement) => HTMLElement | null;
+    hasSlot: (name: string) => boolean;
+};
+
+/**
+ * Functional component props with TypeScript inference for SibuJS.
+ *
+ * Provides utilities to define typed components with prop defaults,
+ * nodes slots, and prop mapping — all with full TypeScript inference.
+ */
+/**
+ * Extract the props type from a component defined with defineComponent.
+ *
+ * @example
+ * ```ts
+ * const Button = defineComponent<{ label: string }>({
+ *   setup(props) { ... }
+ * });
+ * type ButtonProps = ComponentProps<typeof Button>; // { label: string }
+ * ```
+ */
+type ComponentProps<T> = T extends (props: infer P) => HTMLElement ? P : never;
+/**
+ * Props that include an optional nodes slot.
+ */
+type WithNodes<Props> = Props & {
+    nodes?: Node | Node[];
+};
+/**
+ * Define a typed component with props inference, defaults, and a setup function.
+ *
+ * The `setup` function receives merged props (defaults + provided) and must
+ * return an HTMLElement. TypeScript infers the full props type from the generic.
+ *
+ * @param config Component configuration with optional defaults and a setup function
+ * @returns A component function that accepts props and returns an HTMLElement
+ *
+ * @example
+ * ```ts
+ * const Button = defineComponent<{ label: string; variant?: 'primary' | 'secondary'; disabled?: boolean }>({
+ *   defaults: { variant: 'primary', disabled: false },
+ *   setup(props) {
+ *     return button({
+ *       class: `btn btn-${props.variant}`,
+ *       disabled: props.disabled,
+ *       nodes: props.label
+ *     });
+ *   }
+ * });
+ *
+ * // Usage: Button({ label: 'Click me' }) — TypeScript infers props
+ * ```
+ */
+declare function defineComponent<Props extends Record<string, unknown>>(config: {
+    defaults?: Partial<Props>;
+    setup: (props: Props) => HTMLElement;
+}): (props: Props) => HTMLElement;
+/**
+ * Create a component with nodes slot support.
+ *
+ * Nodes are passed as a special `nodes` prop alongside the component's
+ * own props. This enables composition patterns where a parent component
+ * wraps arbitrary child content.
+ *
+ * @param config Component configuration with optional defaults and a setup function
+ * @returns A component function that accepts props (including nodes) and returns an HTMLElement
+ *
+ * @example
+ * ```ts
+ * const Card = defineSlottedComponent<{ title: string }>({
+ *   setup(props) {
+ *     const el = div({ class: 'card' });
+ *     el.appendChild(h2({ nodes: props.title }));
+ *     if (props.nodes) {
+ *       const nodes = Array.isArray(props.nodes) ? props.nodes : [props.nodes];
+ *       nodes.forEach(child => el.appendChild(child));
+ *     }
+ *     return el;
+ *   }
+ * });
+ *
+ * // Usage: Card({ title: 'Hello', nodes: p({ nodes: 'World' }) })
+ * ```
+ */
+declare function defineSlottedComponent<Props extends Record<string, unknown>>(config: {
+    defaults?: Partial<Props>;
+    setup: (props: WithNodes<Props>) => HTMLElement;
+}): (props: WithNodes<Props>) => HTMLElement;
+/**
+ * Higher-order helper to create a component that maps outer props to inner props.
+ *
+ * Useful for adapting a generic component to a specific use case by transforming
+ * the prop interface without modifying the original component.
+ *
+ * @param component The inner component to forward mapped props to
+ * @param mapProps A function that transforms outer props into inner props
+ * @returns A new component that accepts outer props
+ *
+ * @example
+ * ```ts
+ * const IconButton = defineComponent<{ icon: string; label: string; size: number }>({
+ *   setup(props) { ... }
+ * });
+ *
+ * const SmallIconButton = withProps(IconButton, (outer: { icon: string; label: string }) => ({
+ *   icon: outer.icon,
+ *   label: outer.label,
+ *   size: 16
+ * }));
+ *
+ * // Usage: SmallIconButton({ icon: 'star', label: 'Favorite' })
+ * ```
+ */
+declare function withProps<OuterProps extends Record<string, unknown>, InnerProps extends Record<string, unknown>>(component: (props: InnerProps) => HTMLElement, mapProps: (outer: OuterProps) => InnerProps): (props: OuterProps) => HTMLElement;
+
+/**
+ * Runtime prop validation and strict typing contracts for SibuJS.
+ * Provides runtime type checking for component props in development mode.
+ */
+/** Validator function: returns true if valid, or an error message string. */
+type Validator<T = unknown> = (value: T, propName: string) => true | string;
+/** Built-in validators */
+declare const validators: {
+    string: Validator;
+    number: Validator;
+    boolean: Validator;
+    function: Validator;
+    object: Validator;
+    array: Validator;
+    required: Validator;
+    oneOf: <T>(...values: T[]) => Validator<T>;
+    instanceOf: <T>(ctor: new (...args: unknown[]) => T) => Validator<T>;
+    arrayOf: (itemValidator: Validator) => Validator<unknown[]>;
+    shape: (schema: Record<string, Validator>) => Validator<Record<string, unknown>>;
+    optional: (validator: Validator) => Validator;
+    range: (min: number, max: number) => Validator<number>;
+    pattern: (regex: RegExp) => Validator<string>;
+};
+interface PropDef<T = unknown> {
+    type?: Validator<T>;
+    required?: boolean;
+    default?: T | (() => T);
+    validator?: Validator<T>;
+}
+type PropSchema<Props> = {
+    [K in keyof Props]: PropDef<Props[K]> | Validator<Props[K]>;
+};
+/**
+ * Validate props against a schema. Returns validated props with defaults applied.
+ * In production mode (process.env.NODE_ENV === 'production'), validation is skipped
+ * and only defaults are applied for performance.
+ */
+declare function validateProps<Props extends Record<string, unknown>>(props: Partial<Props>, schema: PropSchema<Props>): Props;
+/**
+ * Define a component with runtime prop validation.
+ * Validates props in development mode, applies defaults, then calls setup.
+ */
+declare function defineStrictComponent<Props extends Record<string, unknown>>(config: {
+    name: string;
+    props: PropSchema<Props>;
+    setup: (props: Props) => HTMLElement;
+}): (props: Partial<Props>) => HTMLElement;
+/**
+ * Assert that a value satisfies a contract at runtime.
+ * No-op in production builds.
+ */
+declare function assertType<T>(value: unknown, validator: Validator<T>, label?: string): asserts value is T;
+/**
+ * Create a type guard function from a validator.
+ */
+declare function createGuard<T>(validator: Validator<T>): (value: unknown) => value is T;
+
+export { type ComponentProps as C, type PropDef as P, RenderProp as R, type Validator as V, type PropSchema as a, assertType as b, composable as c, compose as d, createGuard as e, createSlots as f, defineComponent as g, defineSlottedComponent as h, defineStrictComponent as i, validators as j, withDefaults as k, withProps as l, withWrapper as m, validateProps as v, withBoundary as w };