@akashjs/runtime 0.2.2 → 0.2.7

package/dist/virtual-list.cjs.map

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

package/dist/virtual-list.d.cts

@@ -0,0 +1,67 @@
+import { C as Component } from './component-CxlupKuc.cjs';
+import { A as AkashNode } from './types-DjZCk1xT.cjs';
+import { R as ReadonlySignal } from './signals-DionyGGY.cjs';
+
+interface VirtualForProps<T> {
+    /** Array of items */
+    each: T[];
+    /** Key function for reconciliation */
+    key: (item: T) => unknown;
+    /** Fixed height per item in pixels */
+    itemHeight: number;
+    /** Container height in pixels (default: auto-detect from parent) */
+    containerHeight?: number;
+    /** Number of extra items to render above/below viewport */
+    overscan?: number;
+    /** Render function for each item */
+    children: (item: T, index: number) => AkashNode;
+}
+interface VirtualRange {
+    /** First visible index */
+    start: number;
+    /** Last visible index (exclusive) */
+    end: number;
+    /** Total content height in pixels */
+    totalHeight: number;
+    /** Offset of the first rendered item */
+    offsetTop: number;
+}
+/**
+ * Calculate the visible range given scroll position and dimensions.
+ */
+declare function calculateRange(scrollTopOrOpts: number | {
+    scrollTop: number;
+    containerHeight: number;
+    itemHeight: number;
+    totalItems: number;
+    overscan?: number;
+}, containerHeight?: number, itemHeight?: number, totalItems?: number, overscan?: number): VirtualRange;
+/**
+ * Low-level virtual list composable for custom implementations.
+ *
+ * ```ts
+ * const { containerRef, range, visibleItems } = useVirtualList({
+ *   items: () => allItems(),
+ *   itemHeight: 40,
+ *   overscan: 5,
+ * });
+ * ```
+ */
+declare function useVirtualList<T>(options: {
+    items: () => T[];
+    itemHeight: number;
+    containerHeight?: number;
+    overscan?: number;
+}): {
+    range: ReadonlySignal<VirtualRange>;
+    visibleItems: ReadonlySignal<{
+        item: T;
+        index: number;
+    }[]>;
+    onScroll: (e: Event) => void;
+    setContainerHeight: (height: number) => void;
+    scrollTop: ReadonlySignal<number>;
+};
+declare const VirtualFor: Component<VirtualForProps<any>>;
+
+export { VirtualFor, type VirtualForProps, type VirtualRange, calculateRange, useVirtualList };

package/dist/virtual-list.d.ts

@@ -0,0 +1,67 @@
+import { C as Component } from './component-CPVtkASo.js';
+import { A as AkashNode } from './types-DjZCk1xT.js';
+import { R as ReadonlySignal } from './signals-DionyGGY.js';
+
+interface VirtualForProps<T> {
+    /** Array of items */
+    each: T[];
+    /** Key function for reconciliation */
+    key: (item: T) => unknown;
+    /** Fixed height per item in pixels */
+    itemHeight: number;
+    /** Container height in pixels (default: auto-detect from parent) */
+    containerHeight?: number;
+    /** Number of extra items to render above/below viewport */
+    overscan?: number;
+    /** Render function for each item */
+    children: (item: T, index: number) => AkashNode;
+}
+interface VirtualRange {
+    /** First visible index */
+    start: number;
+    /** Last visible index (exclusive) */
+    end: number;
+    /** Total content height in pixels */
+    totalHeight: number;
+    /** Offset of the first rendered item */
+    offsetTop: number;
+}
+/**
+ * Calculate the visible range given scroll position and dimensions.
+ */
+declare function calculateRange(scrollTopOrOpts: number | {
+    scrollTop: number;
+    containerHeight: number;
+    itemHeight: number;
+    totalItems: number;
+    overscan?: number;
+}, containerHeight?: number, itemHeight?: number, totalItems?: number, overscan?: number): VirtualRange;
+/**
+ * Low-level virtual list composable for custom implementations.
+ *
+ * ```ts
+ * const { containerRef, range, visibleItems } = useVirtualList({
+ *   items: () => allItems(),
+ *   itemHeight: 40,
+ *   overscan: 5,
+ * });
+ * ```
+ */
+declare function useVirtualList<T>(options: {
+    items: () => T[];
+    itemHeight: number;
+    containerHeight?: number;
+    overscan?: number;
+}): {
+    range: ReadonlySignal<VirtualRange>;
+    visibleItems: ReadonlySignal<{
+        item: T;
+        index: number;
+    }[]>;
+    onScroll: (e: Event) => void;
+    setContainerHeight: (height: number) => void;
+    scrollTop: ReadonlySignal<number>;
+};
+declare const VirtualFor: Component<VirtualForProps<any>>;
+
+export { VirtualFor, type VirtualForProps, type VirtualRange, calculateRange, useVirtualList };

package/dist/virtual-list.js

@@ -0,0 +1,2 @@
+export{c as VirtualFor,a as calculateRange,b as useVirtualList}from'./chunk-Q6S7SUOM.js';import'./chunk-KE7BJTCD.js';import'./chunk-VUMMC2P5.js';import'./chunk-AOFLE33X.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=virtual-list.js.map
+//# sourceMappingURL=virtual-list.js.map

package/dist/virtual-list.js.map

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

package/dist/watch.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkV2JDKH3W_cjs=require('./chunk-V2JDKH3W.cjs');require('./chunk-WOZWFMOK.cjs'),require('./chunk-XPLIEN2G.cjs');Object.defineProperty(exports,"watch",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.a}});Object.defineProperty(exports,"watchDebounced",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.c}});Object.defineProperty(exports,"watchOnce",{enumerable:true,get:function(){return chunkV2JDKH3W_cjs.b}});//# sourceMappingURL=watch.cjs.map
+//# sourceMappingURL=watch.cjs.map

package/dist/watch.cjs.map

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

package/dist/watch.d.cts

@@ -0,0 +1,70 @@
+/**
+ * watch() — react to signal changes with old/new values.
+ *
+ * Unlike effect() which just re-runs, watch() gives you the previous
+ * and current value so you can react to *what changed*.
+ *
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With options:
+ * watch(count, callback, { immediate: true, once: true });
+ *
+ * // Multiple sources:
+ * watch([count, name], ([newCount, newName], [oldCount, oldName]) => { ... });
+ * ```
+ */
+interface WatchOptions {
+    /** Run callback immediately with current value (default: false) */
+    immediate?: boolean;
+    /** Only fire once, then auto-dispose (default: false) */
+    once?: boolean;
+    /** Debounce callback in ms */
+    debounce?: number;
+    /** Deep comparison for objects (default: false) */
+    deep?: boolean;
+}
+type WatchSource<T> = () => T;
+type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
+type WatchArrayCallback<T extends unknown[]> = (newValues: T, oldValues: (T[number] | undefined)[]) => void;
+/**
+ * Watch a reactive source and call back with old + new values.
+ *
+ * ```ts
+ * const dispose = watch(count, (newVal, oldVal) => {
+ *   analytics.track('count_changed', { from: oldVal, to: newVal });
+ * });
+ * ```
+ */
+declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch multiple sources.
+ */
+declare function watch<T extends unknown[]>(sources: {
+    [K in keyof T]: WatchSource<T[K]>;
+}, callback: WatchArrayCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch a source once, then auto-dispose.
+ *
+ * ```ts
+ * watchOnce(isReady, (ready) => {
+ *   if (ready) initApp();
+ * });
+ * ```
+ */
+declare function watchOnce<T>(source: WatchSource<T>, callback: WatchCallback<T>): () => void;
+/**
+ * Watch with built-in debounce.
+ *
+ * ```ts
+ * watchDebounced(searchInput, (query) => {
+ *   fetchResults(query);
+ * }, 300);
+ * ```
+ */
+declare function watchDebounced<T>(source: WatchSource<T>, callback: WatchCallback<T>, ms: number): () => void;
+
+export { type WatchArrayCallback, type WatchCallback, type WatchOptions, type WatchSource, watch, watchDebounced, watchOnce };

package/dist/watch.d.ts

@@ -0,0 +1,70 @@
+/**
+ * watch() — react to signal changes with old/new values.
+ *
+ * Unlike effect() which just re-runs, watch() gives you the previous
+ * and current value so you can react to *what changed*.
+ *
+ * ```ts
+ * const count = signal(0);
+ * watch(count, (newVal, oldVal) => {
+ *   console.log(`Changed from ${oldVal} to ${newVal}`);
+ * });
+ *
+ * // With options:
+ * watch(count, callback, { immediate: true, once: true });
+ *
+ * // Multiple sources:
+ * watch([count, name], ([newCount, newName], [oldCount, oldName]) => { ... });
+ * ```
+ */
+interface WatchOptions {
+    /** Run callback immediately with current value (default: false) */
+    immediate?: boolean;
+    /** Only fire once, then auto-dispose (default: false) */
+    once?: boolean;
+    /** Debounce callback in ms */
+    debounce?: number;
+    /** Deep comparison for objects (default: false) */
+    deep?: boolean;
+}
+type WatchSource<T> = () => T;
+type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
+type WatchArrayCallback<T extends unknown[]> = (newValues: T, oldValues: (T[number] | undefined)[]) => void;
+/**
+ * Watch a reactive source and call back with old + new values.
+ *
+ * ```ts
+ * const dispose = watch(count, (newVal, oldVal) => {
+ *   analytics.track('count_changed', { from: oldVal, to: newVal });
+ * });
+ * ```
+ */
+declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch multiple sources.
+ */
+declare function watch<T extends unknown[]>(sources: {
+    [K in keyof T]: WatchSource<T[K]>;
+}, callback: WatchArrayCallback<T>, options?: WatchOptions): () => void;
+/**
+ * Watch a source once, then auto-dispose.
+ *
+ * ```ts
+ * watchOnce(isReady, (ready) => {
+ *   if (ready) initApp();
+ * });
+ * ```
+ */
+declare function watchOnce<T>(source: WatchSource<T>, callback: WatchCallback<T>): () => void;
+/**
+ * Watch with built-in debounce.
+ *
+ * ```ts
+ * watchDebounced(searchInput, (query) => {
+ *   fetchResults(query);
+ * }, 300);
+ * ```
+ */
+declare function watchDebounced<T>(source: WatchSource<T>, callback: WatchCallback<T>, ms: number): () => void;
+
+export { type WatchArrayCallback, type WatchCallback, type WatchOptions, type WatchSource, watch, watchDebounced, watchOnce };

package/dist/watch.js

@@ -0,0 +1,2 @@
+export{a as watch,c as watchDebounced,b as watchOnce}from'./chunk-N5APNCPB.js';import'./chunk-YXKQTEPR.js';import'./chunk-U65WRXZC.js';//# sourceMappingURL=watch.js.map
+//# sourceMappingURL=watch.js.map

package/dist/watch.js.map

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

package/dist/web-component.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkDFYXFKCH_cjs=require('./chunk-DFYXFKCH.cjs');Object.defineProperty(exports,"defineCustomElement",{enumerable:true,get:function(){return chunkDFYXFKCH_cjs.a}});Object.defineProperty(exports,"toCustomElement",{enumerable:true,get:function(){return chunkDFYXFKCH_cjs.b}});//# sourceMappingURL=web-component.cjs.map
+//# sourceMappingURL=web-component.cjs.map

package/dist/web-component.cjs.map

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

package/dist/web-component.d.cts

@@ -0,0 +1,51 @@
+import { C as Component } from './component-CxlupKuc.cjs';
+import './types-DjZCk1xT.cjs';
+
+/**
+ * Web Components output.
+ *
+ * Compile AkashJS components to native Custom Elements that can
+ * be used in any framework or plain HTML.
+ *
+ * ```ts
+ * import { defineCustomElement } from '@akashjs/runtime';
+ * import Counter from './Counter.akash';
+ *
+ * defineCustomElement('my-counter', Counter, {
+ *   props: ['initial'],
+ *   shadow: true,
+ * });
+ *
+ * // Now usable as: <my-counter initial="5"></my-counter>
+ * ```
+ */
+
+interface CustomElementOptions {
+    /** Props to observe as attributes */
+    props?: string[];
+    /** Use Shadow DOM (default: true) */
+    shadow?: boolean;
+    /** CSS styles to inject (for shadow DOM) */
+    styles?: string;
+    /** Extend an existing element */
+    extends?: string;
+}
+/**
+ * Register an AkashJS component as a Custom Element.
+ *
+ * ```ts
+ * defineCustomElement('my-counter', Counter, {
+ *   props: ['initial', 'step'],
+ *   shadow: true,
+ *   styles: ':host { display: block; }',
+ * });
+ * ```
+ */
+declare function defineCustomElement<P extends Record<string, unknown>>(tagName: string, component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
+/**
+ * Convert an AkashJS component to a Custom Element class without registering.
+ * Useful for testing or when you want to register later.
+ */
+declare function toCustomElement<P extends Record<string, unknown>>(component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
+
+export { type CustomElementOptions, defineCustomElement, toCustomElement };

package/dist/web-component.d.ts

@@ -0,0 +1,51 @@
+import { C as Component } from './component-CPVtkASo.js';
+import './types-DjZCk1xT.js';
+
+/**
+ * Web Components output.
+ *
+ * Compile AkashJS components to native Custom Elements that can
+ * be used in any framework or plain HTML.
+ *
+ * ```ts
+ * import { defineCustomElement } from '@akashjs/runtime';
+ * import Counter from './Counter.akash';
+ *
+ * defineCustomElement('my-counter', Counter, {
+ *   props: ['initial'],
+ *   shadow: true,
+ * });
+ *
+ * // Now usable as: <my-counter initial="5"></my-counter>
+ * ```
+ */
+
+interface CustomElementOptions {
+    /** Props to observe as attributes */
+    props?: string[];
+    /** Use Shadow DOM (default: true) */
+    shadow?: boolean;
+    /** CSS styles to inject (for shadow DOM) */
+    styles?: string;
+    /** Extend an existing element */
+    extends?: string;
+}
+/**
+ * Register an AkashJS component as a Custom Element.
+ *
+ * ```ts
+ * defineCustomElement('my-counter', Counter, {
+ *   props: ['initial', 'step'],
+ *   shadow: true,
+ *   styles: ':host { display: block; }',
+ * });
+ * ```
+ */
+declare function defineCustomElement<P extends Record<string, unknown>>(tagName: string, component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
+/**
+ * Convert an AkashJS component to a Custom Element class without registering.
+ * Useful for testing or when you want to register later.
+ */
+declare function toCustomElement<P extends Record<string, unknown>>(component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
+
+export { type CustomElementOptions, defineCustomElement, toCustomElement };

package/dist/web-component.js

@@ -0,0 +1,2 @@
+export{a as defineCustomElement,b as toCustomElement}from'./chunk-F4FXIPR3.js';//# sourceMappingURL=web-component.js.map
+//# sourceMappingURL=web-component.js.map

package/dist/web-component.js.map

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