@ktjs/core 0.29.8 → 0.29.9

package/dist/index.d.ts

@@ -1,10 +1,428 @@
-export * from './h/index.js';
-export * from './jsx/index.js';
-export * from './reactive/index.js';
-export { KTAsync } from './jsx/async.js';
-export { KTFor } from './jsx/for.js';
-export type { KTForProps, KTForElement } from './jsx/for.js';
-export type { HTMLTag, SVGTag, MathMLTag, InputElementTag } from '@ktjs/shared';
-export type { KTRawContent, KTRawContents, KTRawAttr, EventHandler, KTAttribute, KTPrefixedEventAttribute, } from './types/h.js';
-export type * from './types/jsx.js';
-export type * from './types/reactive.js';
+import { HTMLTag } from '@ktjs/shared';
+import { InputElementTag } from '@ktjs/shared';
+import { JSXTag } from '@ktjs/shared';
+import { MathMLTag } from '@ktjs/shared';
+import { otherstring } from '@ktjs/shared';
+import { SVGTag } from '@ktjs/shared';
+
+/**
+ * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render
+ */
+export declare const $initRef: <T extends Node>(props: {
+    ref?: KTRef<T>;
+}, node: T) => RefSetter<T>;
+
+/**
+ * Assert k-model to be a ref object
+ */
+export declare const $modelOrRef: <T = any>(props: any, defaultValue?: T) => KTRef<T>;
+
+/**
+ * Create a reactive computed value
+ * @param computeFn
+ * @param reactives refs and computeds that this computed depends on
+ */
+export declare function computed<T = JSX.Element>(computeFn: () => T, reactives: Array<KTReactive<any>>): KTComputed<T>;
+
+/**
+ * A helper to create redrawable elements
+ * ```tsx
+ * export function MyComponent() {
+ *    let aa = 10;
+ *    // ...
+ *    // aa might be changed
+ *    return createRedrawable(() => <div>{aa}</div>);
+ * }
+ * ```
+ * Then the returned element has a `redraw` method to redraw itself with new values.
+ * @param creator a simple creator function that returns an element
+ * @returns created element's ref
+ */
+export declare function createRedrawable<T>(creator: () => T): KTRef<T> & {
+    redraw: () => T;
+};
+
+/**
+ * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.
+ */
+export declare function dereactive<T = JSX.Element>(value: T | KTReactive<T>): T;
+
+/**
+ * Register a reactive effect with options.
+ * @param effectFn The effect function to run when dependencies change
+ * @param reactives The reactive dependencies
+ * @param options Effect options: lazy, onCleanup, debugName
+ * @returns stop function to remove all listeners
+ */
+export declare function effect(effectFn: () => void, reactives: Array<KTReactive<any>>, options?: Partial<KTEffectOptions>): () => void;
+
+/**
+ * Event handler type for DOM events
+ */
+export declare type EventHandler<T extends Event = Event> = (this: HTMLElement, ev: T) => any;
+
+/**
+ * Extract component props type (excluding ref and children)
+ */
+declare type ExtractComponentProps<T> = T extends (props: infer P) => any ? Omit<P, 'ref' | 'children'> : {};
+
+/**
+ * Fragment support - returns an array of children
+ * Enhanced Fragment component that manages arrays of elements
+ */
+export declare function Fragment(props: {
+    children?: KTRawContent;
+}): JSX.Element;
+
+/**
+ * Create an enhanced HTMLElement.
+ * - Only supports HTMLElements, **NOT** SVGElements or other Elements.
+ * @param tag tag of an `HTMLElement`
+ * @param attr attribute object or className
+ * @param content a string or an array of HTMLEnhancedElement as child nodes
+ *
+ * __PKG_INFO__
+ */
+declare const h: <T extends HTMLTag | SVGTag | MathMLTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent) => HTML<T>;
+export { h as createElement }
+export { h }
+
+declare type HTML<T extends (HTMLTag | SVGTag | MathMLTag) & otherstring> = T extends SVGTag
+? SVGElementTagNameMap[T]
+: T extends HTMLTag
+? HTMLElementTagNameMap[T]
+: T extends MathMLTag
+? MathMLElementTagNameMap[T]
+: HTMLElement;
+
+export { HTMLTag }
+
+export { InputElementTag }
+
+export declare const isComputed: <T = any>(obj: any) => obj is KTComputed<T>;
+
+export declare const isKT: <T = any>(obj: any) => obj is KTReactive<T>;
+
+export declare const isRef: <T = any>(obj: any) => obj is KTRef<T>;
+
+/**
+ * @param tag html tag or function component
+ * @param props properties/attributes
+ */
+export declare function jsx(tag: JSXTag, props: KTAttribute): JSX.Element;
+
+/**
+ * JSX Development runtime - same as jsx but with additional dev checks
+ */
+export declare const jsxDEV: typeof jsx;
+
+/**
+ * JSX runtime for React 17+ automatic runtime
+ * This is called when using jsx: "react-jsx" or "react-jsxdev"
+ */
+export declare const jsxs: typeof jsx;
+
+export declare function KTAsync<T extends KTComponent>(props: {
+    ref?: KTRef<JSX.Element>;
+    skeleton?: JSX.Element;
+    component: T;
+    children?: KTRawContent;
+} & ExtractComponentProps<T>): JSX.Element;
+
+export declare type KTAttribute = KTBaseAttribute & KTPrefixedEventAttribute;
+
+declare type KTAvailableContent = SingleContent | KTAvailableContent[];
+
+/**
+ * Used to create enhanced HTML elements
+ */
+declare interface KTBaseAttribute {
+    [k: string]: any;
+
+    // # kt-specific attributes
+    ref?: KTRef<JSX.Element>;
+
+    /**
+     * If a `KTRef` is bound, it will be reactive; otherwise, it will be static.
+     */
+    'k-if'?: any;
+
+    /**
+     * Register two-way data binding between an input element and a KTRef.
+     * - Default to regist `input` event and `value` property(`checked` for checkboxes and radios).
+     */
+    'k-model'?: KTRef<any>;
+
+    /**
+     * Directly apply html string to `innerHTML`.
+     * - Would be reactive if `KTRef` instance is provided
+     */
+    'k-html'?: any;
+
+    // # normal HTML attributes
+    id?: string;
+    class?: string;
+    className?: string;
+    style?: string | Partial<CSSStyleDeclaration>;
+
+    type?:
+    | 'text'
+    | 'password'
+    | 'email'
+    | 'number'
+    | 'tel'
+    | 'url'
+    | 'search'
+    | 'date'
+    | 'datetime-local'
+    | 'time'
+    | 'month'
+    | 'week'
+    | 'color'
+    | 'range'
+    | 'file'
+    | 'checkbox'
+    | 'radio'
+    | 'hidden'
+    | 'submit'
+    | 'reset'
+    | 'button'
+    | 'image'
+    | otherstring;
+    for?: string;
+
+    name?: string;
+    title?: string;
+    placeholder?: string;
+    contenteditable?: boolean;
+    value?: any;
+    valueAsDate?: Date;
+    valueAsNumber?: number;
+    label?: string;
+    disabled?: boolean;
+
+    min?: string | number;
+    max?: string | number;
+    step?: string | number;
+
+    selected?: boolean;
+    checked?: boolean;
+
+    action?: string;
+    method?: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE' | otherstring;
+}
+
+declare type KTComponent = (
+props: {
+    ref?: KTRef<JSX.Element>;
+    children?: KTRawContent;
+} & KTAttribute &
+any,
+) => JSX.Element | Promise<JSX.Element> | any;
+
+export declare class KTComputed<T> implements KTReactive<T> {
+    /**
+     * Indicates that this is a KTRef instance
+     */
+    isKT: true;
+    ktType: KTReactiveType;
+    /* Excluded from this release type: _calculator */
+    /* Excluded from this release type: _value */
+    /* Excluded from this release type: _onChanges */
+    /* Excluded from this release type: _emit */
+    /* Excluded from this release type: _recalculate */
+    /* Excluded from this release type: _subscribe */
+    constructor(_calculator: () => T, reactives: Array<KTReactive<unknown>>);
+    /**
+     * If new value and old value are both nodes, the old one will be replaced in the DOM
+     */
+    get value(): T;
+    set value(_newValue: T);
+    /**
+     * Force listeners to run once with the latest computed result.
+     */
+    notify(): void;
+    /**
+     * Computed values are derived from dependencies and should not be mutated manually.
+     */
+    mutate<R = void>(): R;
+    /**
+     * Register a callback when the value changes
+     * @param callback (newValue, oldValue) => xxx
+     */
+    addOnChange(callback: ReactiveChangeHandler<T>): void;
+    /**
+     * Unregister a callback
+     * @param callback (newValue, oldValue) => xxx
+     */
+    removeOnChange(callback: ReactiveChangeHandler<T>): boolean;
+}
+
+declare interface KTEffectOptions {
+    lazy: boolean;
+    onCleanup: () => void;
+    debugName: string;
+}
+
+/**
+ * KTFor - List rendering component with key-based optimization
+ * Returns a Comment anchor node with rendered elements in __kt_for_list__
+ */
+export declare function KTFor<T>(props: KTForProps<T>): KTForElement;
+
+export declare type KTForElement = JSX.Element;
+
+export declare interface KTForProps<T> {
+    ref?: KTRef<KTForElement>;
+    list: T[] | KTReactive<T[]>;
+    key?: (item: T, index: number, array: T[]) => any;
+    map: (item: T, index: number, array: T[]) => HTMLElement;
+}
+
+export declare type KTPrefixedEventAttribute = {
+    [EventName in keyof HTMLElementEventMap as `on:${EventName}`]?: (ev: HTMLElementEventMap[EventName]) => void;
+};
+
+export declare type KTRawAttr = KTAttribute | null | undefined | '' | false;
+
+export declare type KTRawContent = KTAvailableContent | Promise<KTAvailableContent>;
+
+export declare type KTRawContents = KTAvailableContent;
+
+export declare type KTReactify<T> = T extends boolean ? KTReactive<boolean> : T extends any ? KTReactive<T> : never;
+
+export declare type KTReactifyObject<T extends object> = {
+    [K in keyof T]: KTReactify<T[K]>;
+};
+
+export declare type KTReactifyProps<T extends object> = {
+    [K in keyof T]: KTReactify<Exclude<T[K], undefined>> | T[K];
+};
+
+export declare class KTReactive<T> {
+    /**
+     * Indicates that this is a KTRef instance
+     */
+    isKT: boolean;
+
+    ktType: KTReactiveType;
+
+    /**
+     * If new value and old value are both nodes, the old one will be replaced in the DOM
+     */
+    get value();
+    set value(newValue: T);
+
+    /**
+     * Force all listeners to run even when reference identity has not changed.
+     * Useful for in-place array/object mutations.
+     */
+    notify(): void;
+
+    /**
+     * Mutate current value in-place and notify listeners once.
+     *
+     * @example
+     * const items = ref<number[]>([1, 2]);
+     * items.mutate((list) => list.push(3));
+     */
+    mutate<R = void>(mutator: (currentValue: T) => R): R;
+
+    /**
+     * Register a callback when the value changes
+     * - Value setter will check `Object.is(newValue, oldValue)`.
+     * @param callback (newValue, oldValue) => xxx
+     */
+    addOnChange(callback: ReactiveChangeHandler<T>): void;
+    removeOnChange(callback: ReactiveChangeHandler<T>): void;
+}
+
+export declare const enum KTReactiveType {
+    REF = 1,
+    COMPUTED = 2
+}
+
+export declare class KTRef<T> implements KTReactive<T> {
+    /**
+     * Indicates that this is a KTRef instance
+     */
+    isKT: true;
+    ktType: KTReactiveType;
+    /* Excluded from this release type: _value */
+    /* Excluded from this release type: _onChanges */
+    /* Excluded from this release type: _emit */
+    constructor(_value: T, _onChanges: Array<ReactiveChangeHandler<T>>);
+    /**
+     * If new value and old value are both nodes, the old one will be replaced in the DOM
+     */
+    get value(): T;
+    set value(newValue: T);
+    /**
+     * Force all listeners to run even when reference identity has not changed.
+     * Useful for in-place array/object mutations.
+     */
+    notify(): void;
+    /**
+     * Mutate current value in-place and notify listeners once.
+     *
+     * @example
+     * const items = ref<number[]>([1, 2]);
+     * items.mutate((list) => list.push(3));
+     */
+    mutate<R = void>(mutator: (currentValue: T) => R): R;
+    /**
+     * Register a callback when the value changes
+     * @param callback (newValue, oldValue) => xxx
+     */
+    addOnChange(callback: ReactiveChangeHandler<T>): void;
+    removeOnChange(callback: ReactiveChangeHandler<T>): boolean;
+}
+
+export declare type KTSurfaceRef<T extends object> = {
+    [K in keyof T]: KTRef<T[K]>;
+} & {
+    /**
+     * Get the dereferenced object like the original one
+     */
+    kcollect: () => T;
+};
+
+export { MathMLTag }
+
+export declare type ReactiveChangeHandler<T> = (newValue: T, oldValue: T) => void;
+
+/**
+ * Reference to the created HTML element.
+ * - **Only** respond to `ref.value` changes, not reactive to internal changes of the element.
+ * - can alse be used to store normal values, but it is not reactive.
+ * - if the value is already a `KTRef`, it will be returned **directly**.
+ * @param value mostly an HTMLElement
+ */
+export declare function ref<T = JSX.Element>(value?: T, onChange?: ReactiveChangeHandler<T>): KTRef<T>;
+
+declare type RefSetter<T> = (props: {
+    ref?: KTRef<T>;
+}, node: T) => void;
+
+declare type SingleContent = KTRef<any> | HTMLElement | Element | Node | string | number | boolean | null | undefined;
+
+/**
+ * Make all first-level properties of the object a `KTRef`.
+ * - `obj.a.b` is not reactive
+ */
+export declare const surfaceRef: <T extends object>(obj: T) => KTSurfaceRef<T>;
+
+export { SVGTag }
+
+export declare const toReactive: <T>(value: T | KTReactive<T>, onChange?: ReactiveChangeHandler<T>) => KTReactive<T>;
+
+/**
+ * Convert a value to `KTRef`.
+ * - Returns the original value if it is already a `KTRef`.
+ * - Throws error if the value is a `KTComputed`.
+ * - Otherwise wraps the value with `ref()`.
+ * @param o value to convert
+ */
+export declare const toRef: <T = any>(o: any) => KTRef<T>;
+
+export { }

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,245 @@
+import { HTMLTag } from '@ktjs/shared';
+import { JSXTag } from '@ktjs/shared';
+import { MathMLTag } from '@ktjs/shared';
+import { otherstring } from '@ktjs/shared';
+import { SVGTag } from '@ktjs/shared';
+
+/**
+ * A helper to create redrawable elements
+ * ```tsx
+ * export function MyComponent() {
+ *    let aa = 10;
+ *    // ...
+ *    // aa might be changed
+ *    return createRedrawable(() => <div>{aa}</div>);
+ * }
+ * ```
+ * Then the returned element has a `redraw` method to redraw itself with new values.
+ * @param creator a simple creator function that returns an element
+ * @returns created element's ref
+ */
+export declare function createRedrawable<T>(creator: () => T): KTRef<T> & {
+    redraw: () => T;
+};
+
+/**
+ * Fragment support - returns an array of children
+ * Enhanced Fragment component that manages arrays of elements
+ */
+export declare function Fragment(props: {
+    children?: KTRawContent;
+}): JSX.Element;
+
+/**
+ * Create an enhanced HTMLElement.
+ * - Only supports HTMLElements, **NOT** SVGElements or other Elements.
+ * @param tag tag of an `HTMLElement`
+ * @param attr attribute object or className
+ * @param content a string or an array of HTMLEnhancedElement as child nodes
+ *
+ * __PKG_INFO__
+ */
+declare const h: <T extends HTMLTag | SVGTag | MathMLTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent) => HTML<T>;
+export { h as createElement }
+export { h }
+
+declare type HTML<T extends (HTMLTag | SVGTag | MathMLTag) & otherstring> = T extends SVGTag
+? SVGElementTagNameMap[T]
+: T extends HTMLTag
+? HTMLElementTagNameMap[T]
+: T extends MathMLTag
+? MathMLElementTagNameMap[T]
+: HTMLElement;
+
+/**
+ * @param tag html tag or function component
+ * @param props properties/attributes
+ */
+export declare function jsx(tag: JSXTag, props: KTAttribute): JSX.Element;
+
+/**
+ * JSX Development runtime - same as jsx but with additional dev checks
+ */
+export declare const jsxDEV: typeof jsx;
+
+/**
+ * JSX runtime for React 17+ automatic runtime
+ * This is called when using jsx: "react-jsx" or "react-jsxdev"
+ */
+export declare const jsxs: typeof jsx;
+
+declare type KTAttribute = KTBaseAttribute & KTPrefixedEventAttribute;
+
+declare type KTAvailableContent = SingleContent | KTAvailableContent[];
+
+/**
+ * Used to create enhanced HTML elements
+ */
+declare interface KTBaseAttribute {
+    [k: string]: any;
+
+    // # kt-specific attributes
+    ref?: KTRef<JSX.Element>;
+
+    /**
+     * If a `KTRef` is bound, it will be reactive; otherwise, it will be static.
+     */
+    'k-if'?: any;
+
+    /**
+     * Register two-way data binding between an input element and a KTRef.
+     * - Default to regist `input` event and `value` property(`checked` for checkboxes and radios).
+     */
+    'k-model'?: KTRef<any>;
+
+    /**
+     * Directly apply html string to `innerHTML`.
+     * - Would be reactive if `KTRef` instance is provided
+     */
+    'k-html'?: any;
+
+    // # normal HTML attributes
+    id?: string;
+    class?: string;
+    className?: string;
+    style?: string | Partial<CSSStyleDeclaration>;
+
+    type?:
+    | 'text'
+    | 'password'
+    | 'email'
+    | 'number'
+    | 'tel'
+    | 'url'
+    | 'search'
+    | 'date'
+    | 'datetime-local'
+    | 'time'
+    | 'month'
+    | 'week'
+    | 'color'
+    | 'range'
+    | 'file'
+    | 'checkbox'
+    | 'radio'
+    | 'hidden'
+    | 'submit'
+    | 'reset'
+    | 'button'
+    | 'image'
+    | otherstring;
+    for?: string;
+
+    name?: string;
+    title?: string;
+    placeholder?: string;
+    contenteditable?: boolean;
+    value?: any;
+    valueAsDate?: Date;
+    valueAsNumber?: number;
+    label?: string;
+    disabled?: boolean;
+
+    min?: string | number;
+    max?: string | number;
+    step?: string | number;
+
+    selected?: boolean;
+    checked?: boolean;
+
+    action?: string;
+    method?: 'POST' | 'GET' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE' | otherstring;
+}
+
+declare type KTPrefixedEventAttribute = {
+    [EventName in keyof HTMLElementEventMap as `on:${EventName}`]?: (ev: HTMLElementEventMap[EventName]) => void;
+};
+
+declare type KTRawAttr = KTAttribute | null | undefined | '' | false;
+
+declare type KTRawContent = KTAvailableContent | Promise<KTAvailableContent>;
+
+declare class KTReactive<T> {
+    /**
+     * Indicates that this is a KTRef instance
+     */
+    isKT: boolean;
+
+    ktType: KTReactiveType;
+
+    /**
+     * If new value and old value are both nodes, the old one will be replaced in the DOM
+     */
+    get value();
+    set value(newValue: T);
+
+    /**
+     * Force all listeners to run even when reference identity has not changed.
+     * Useful for in-place array/object mutations.
+     */
+    notify(): void;
+
+    /**
+     * Mutate current value in-place and notify listeners once.
+     *
+     * @example
+     * const items = ref<number[]>([1, 2]);
+     * items.mutate((list) => list.push(3));
+     */
+    mutate<R = void>(mutator: (currentValue: T) => R): R;
+
+    /**
+     * Register a callback when the value changes
+     * - Value setter will check `Object.is(newValue, oldValue)`.
+     * @param callback (newValue, oldValue) => xxx
+     */
+    addOnChange(callback: ReactiveChangeHandler<T>): void;
+    removeOnChange(callback: ReactiveChangeHandler<T>): void;
+}
+
+declare const enum KTReactiveType {
+    REF = 1,
+    COMPUTED = 2
+}
+
+declare class KTRef<T> implements KTReactive<T> {
+    /**
+     * Indicates that this is a KTRef instance
+     */
+    isKT: true;
+    ktType: KTReactiveType;
+    /* Excluded from this release type: _value */
+    /* Excluded from this release type: _onChanges */
+    /* Excluded from this release type: _emit */
+    constructor(_value: T, _onChanges: Array<ReactiveChangeHandler<T>>);
+    /**
+     * If new value and old value are both nodes, the old one will be replaced in the DOM
+     */
+    get value(): T;
+    set value(newValue: T);
+    /**
+     * Force all listeners to run even when reference identity has not changed.
+     * Useful for in-place array/object mutations.
+     */
+    notify(): void;
+    /**
+     * Mutate current value in-place and notify listeners once.
+     *
+     * @example
+     * const items = ref<number[]>([1, 2]);
+     * items.mutate((list) => list.push(3));
+     */
+    mutate<R = void>(mutator: (currentValue: T) => R): R;
+    /**
+     * Register a callback when the value changes
+     * @param callback (newValue, oldValue) => xxx
+     */
+    addOnChange(callback: ReactiveChangeHandler<T>): void;
+    removeOnChange(callback: ReactiveChangeHandler<T>): boolean;
+}
+
+declare type ReactiveChangeHandler<T> = (newValue: T, oldValue: T) => void;
+
+declare type SingleContent = KTRef<any> | HTMLElement | Element | Node | string | number | boolean | null | undefined;
+
+export { }

package/dist/jsx-runtime.mjs

@@ -0,0 +1 @@
+export { F as Fragment, h as createElement, c as createRedrawable, h, j as jsx, a as jsxDEV, b as jsxs } from './jsx-runtime-DGJHUQEM.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ktjs/core",
-  "version": "0.29.8",
+  "version": "0.29.9",
   "description": "Core functionality for kt.js - DOM manipulation utilities with JSX/TSX support",
   "type": "module",
   "module": "./dist/index.mjs",
@@ -12,16 +12,16 @@
       "default": "./dist/index.mjs"
     },
     "./jsx": {
-      "types": "./dist/jsx/index.d.ts",
-      "import": "./dist/jsx/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
     },
     "./jsx-runtime": {
-      "types": "./dist/jsx/jsx-runtime.d.ts",
-      "import": "./dist/jsx/jsx-runtime.mjs"
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.mjs"
     },
     "./jsx-dev-runtime": {
-      "types": "./dist/jsx/jsx-runtime.d.ts",
-      "import": "./dist/jsx/jsx-runtime.mjs"
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.mjs"
     }
   },
   "files": [

package/dist/h/attr-helpers.d.ts

@@ -1,6 +0,0 @@
-export declare const handlers: Record<string, (element: HTMLElement | SVGElement | MathMLElement, key: string, value: any) => void>;
-type InputElement = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
-type StringEventHandler = (element: InputElement, handler: (value: string) => void) => void;
-type NumberEventHandler = (element: InputElement, handler: (value: number) => void) => void;
-export declare const ktEventHandlers: Record<string, StringEventHandler | NumberEventHandler>;
-export {};

package/dist/h/attr.d.ts

@@ -1,2 +0,0 @@
-import { KTRawAttr } from '../types/h.js';
-export declare function applyAttr(element: HTMLElement | SVGElement | MathMLElement, attr: KTRawAttr): void;

package/dist/h/content.d.ts

@@ -1,2 +0,0 @@
-import { KTRawContent } from '../types/h.js';
-export declare function applyContent(element: HTMLElement | SVGElement | MathMLElement, content: KTRawContent): void;

package/dist/h/index.d.ts

@@ -1,12 +0,0 @@
-import { HTMLTag, MathMLTag, SVGTag } from '@ktjs/shared';
-import { KTRawAttr, KTRawContent, HTML } from '../types/h.js';
-/**
- * Create an enhanced HTMLElement.
- * - Only supports HTMLElements, **NOT** SVGElements or other Elements.
- * @param tag tag of an `HTMLElement`
- * @param attr attribute object or className
- * @param content a string or an array of HTMLEnhancedElement as child nodes
- *
- * __PKG_INFO__
- */
-export declare const h: <T extends HTMLTag | SVGTag | MathMLTag>(tag: T, attr?: KTRawAttr, content?: KTRawContent) => HTML<T>;

package/dist/h/model.d.ts

@@ -1,3 +0,0 @@
-import { InputElementTag } from '@ktjs/shared';
-import { KTRef } from '../reactive/index.js';
-export declare function applyKModel(element: HTMLElementTagNameMap[InputElementTag], valueRef: KTRef<any>): void;

package/dist/jsx/async.d.ts

@@ -1,13 +0,0 @@
-import { KTComponent, KTRawContent } from '../types/h.js';
-import { KTRef } from '../reactive/ref.js';
-/**
- * Extract component props type (excluding ref and children)
- */
-type ExtractComponentProps<T> = T extends (props: infer P) => any ? Omit<P, 'ref' | 'children'> : {};
-export declare function KTAsync<T extends KTComponent>(props: {
-    ref?: KTRef<JSX.Element>;
-    skeleton?: JSX.Element;
-    component: T;
-    children?: KTRawContent;
-} & ExtractComponentProps<T>): JSX.Element;
-export {};

package/dist/jsx/common.d.ts

@@ -1,4 +0,0 @@
-import { JSXTag } from '@ktjs/shared';
-import { KTAttribute } from '../types/h.js';
-export declare const jsxh: (tag: JSXTag, props: KTAttribute) => HTMLElement;
-export declare const placeholder: (data: string) => JSX.Element;

package/dist/jsx/for.d.ts

@@ -1,14 +0,0 @@
-import { KTRef } from '../reactive/ref.js';
-import { KTReactive } from '../types/reactive.js';
-export type KTForElement = JSX.Element;
-export interface KTForProps<T> {
-    ref?: KTRef<KTForElement>;
-    list: T[] | KTReactive<T[]>;
-    key?: (item: T, index: number, array: T[]) => any;
-    map: (item: T, index: number, array: T[]) => HTMLElement;
-}
-/**
- * KTFor - List rendering component with key-based optimization
- * Returns a Comment anchor node with rendered elements in __kt_for_list__
- */
-export declare function KTFor<T>(props: KTForProps<T>): KTForElement;

package/dist/jsx/fragment.d.ts

@@ -1,35 +0,0 @@
-import { KTRef } from '../reactive/ref.js';
-import { KTReactive } from '../types/reactive.js';
-import { KTRawContent } from '../types/h.js';
-export interface FragmentProps<T extends HTMLElement = HTMLElement> {
-    /** Array of child elements, supports reactive arrays */
-    children: T[] | KTReactive<T[]>;
-    /** element key function for optimization (future enhancement) */
-    key?: (element: T, index: number, array: T[]) => any;
-    /** ref to get the anchor node */
-    ref?: KTRef<JSX.Element>;
-}
-/**
- * Fragment - Container component for managing arrays of child elements
- *
- * Features:
- * 1. Returns a comment anchor node, child elements are inserted after the anchor
- * 2. Supports reactive arrays, automatically updates DOM when array changes
- * 3. Basic version uses simple replacement algorithm (remove all old elements, insert all new elements)
- * 4. Future enhancement: key-based optimization
- *
- * Usage example:
- * ```tsx
- * const children = ref([<div>A</div>, <div>B</div>]);
- * const fragment = <Fragment children={children} />;
- * document.body.appendChild(fragment);
- *
- * // Automatic update
- * children.value = [<div>C</div>, <div>D</div>];
- * ```
- */
-export declare function Fragment<T extends HTMLElement = HTMLElement>(props: FragmentProps<T>): JSX.Element;
-/**
- * Convert KTRawContent to HTMLElement array
- */
-export declare function convertChildrenToElements(children: KTRawContent): HTMLElement[];

package/dist/jsx/if.d.ts

@@ -1,10 +0,0 @@
-import { JSXTag } from '@ktjs/shared';
-import { KTAttribute } from '../types/h.js';
-import { KElseElement, KIfElement } from '../types/directives.js';
-export declare function kif(tag: JSXTag, props: KTAttribute): KIfElement;
-export declare function kelse(tag: JSXTag, props: KTAttribute): KElseElement;
-/**
- * Deal with `k-if` and `k-else`, checking syntax and applying listeners
- * @param el parent element
- */
-export declare function kifelseApply(el: HTMLElement): void;

package/dist/jsx/index.d.ts

@@ -1,2 +0,0 @@
-export { jsx, jsxs, jsxDEV, Fragment, createElement, createRedrawable } from './jsx-runtime.js';
-export type * from '../types/jsx.js';

package/dist/jsx/index.mjs

@@ -1 +0,0 @@
-export { F as Fragment, h as createElement, c as createRedrawable, j as jsx, a as jsxDEV, b as jsxs } from '../jsx-runtime-DGJHUQEM.js';

package/dist/jsx/jsx-runtime.d.ts

@@ -1,43 +0,0 @@
-import { JSXTag } from '@ktjs/shared';
-import { KTAttribute, KTRawContent } from '../types/h.js';
-import { h } from '../h/index.js';
-import { KTRef } from '../reactive/index.js';
-/**
- * @param tag html tag or function component
- * @param props properties/attributes
- */
-export declare function jsx(tag: JSXTag, props: KTAttribute): JSX.Element;
-/**
- * Fragment support - returns an array of children
- * Enhanced Fragment component that manages arrays of elements
- */
-export declare function Fragment(props: {
-    children?: KTRawContent;
-}): JSX.Element;
-/**
- * JSX Development runtime - same as jsx but with additional dev checks
- */
-export declare const jsxDEV: typeof jsx;
-/**
- * JSX runtime for React 17+ automatic runtime
- * This is called when using jsx: "react-jsx" or "react-jsxdev"
- */
-export declare const jsxs: typeof jsx;
-export { h, h as createElement };
-/**
- * A helper to create redrawable elements
- * ```tsx
- * export function MyComponent() {
- *    let aa = 10;
- *    // ...
- *    // aa might be changed
- *    return createRedrawable(() => <div>{aa}</div>);
- * }
- * ```
- * Then the returned element has a `redraw` method to redraw itself with new values.
- * @param creator a simple creator function that returns an element
- * @returns created element's ref
- */
-export declare function createRedrawable<T>(creator: () => T): KTRef<T> & {
-    redraw: () => T;
-};

package/dist/jsx/jsx-runtime.mjs

@@ -1,2 +0,0 @@
-export { F as Fragment, h as createElement, c as createRedrawable, h, j as jsx, a as jsxDEV, b as jsxs } from '../jsx-runtime-DGJHUQEM.js';
-import '@ktjs/shared';

package/dist/reactive/computed.d.ts

@@ -1,63 +0,0 @@
-import { KTReactive, ReactiveChangeHandler } from '../types/reactive.js';
-import { KTReactiveType } from './core.js';
-export declare class KTComputed<T> implements KTReactive<T> {
-    /**
-     * Indicates that this is a KTRef instance
-     */
-    isKT: true;
-    ktType: KTReactiveType;
-    /**
-     * @internal
-     */
-    private _calculator;
-    /**
-     * @internal
-     */
-    private _value;
-    /**
-     * @internal
-     */
-    private _onChanges;
-    /**
-     * @internal
-     */
-    private _emit;
-    /**
-     * @internal
-     */
-    private _recalculate;
-    /**
-     * @internal
-     */
-    private _subscribe;
-    constructor(_calculator: () => T, reactives: Array<KTReactive<unknown>>);
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     */
-    get value(): T;
-    set value(_newValue: T);
-    /**
-     * Force listeners to run once with the latest computed result.
-     */
-    notify(): void;
-    /**
-     * Computed values are derived from dependencies and should not be mutated manually.
-     */
-    mutate<R = void>(): R;
-    /**
-     * Register a callback when the value changes
-     * @param callback (newValue, oldValue) => xxx
-     */
-    addOnChange(callback: ReactiveChangeHandler<T>): void;
-    /**
-     * Unregister a callback
-     * @param callback (newValue, oldValue) => xxx
-     */
-    removeOnChange(callback: ReactiveChangeHandler<T>): boolean;
-}
-/**
- * Create a reactive computed value
- * @param computeFn
- * @param reactives refs and computeds that this computed depends on
- */
-export declare function computed<T = JSX.Element>(computeFn: () => T, reactives: Array<KTReactive<any>>): KTComputed<T>;

package/dist/reactive/core.d.ts

@@ -1,9 +0,0 @@
-import { KTReactive } from '../types/reactive.js';
-import { KTComputed, KTRef } from './index.js';
-export declare const enum KTReactiveType {
-    REF = 1,
-    COMPUTED = 2
-}
-export declare const isKT: <T = any>(obj: any) => obj is KTReactive<T>;
-export declare const isRef: <T = any>(obj: any) => obj is KTRef<T>;
-export declare const isComputed: <T = any>(obj: any) => obj is KTComputed<T>;

package/dist/reactive/effect.d.ts

@@ -1,15 +0,0 @@
-import { KTReactive } from '../types/reactive.js';
-interface KTEffectOptions {
-    lazy: boolean;
-    onCleanup: () => void;
-    debugName: string;
-}
-/**
- * Register a reactive effect with options.
- * @param effectFn The effect function to run when dependencies change
- * @param reactives The reactive dependencies
- * @param options Effect options: lazy, onCleanup, debugName
- * @returns stop function to remove all listeners
- */
-export declare function effect(effectFn: () => void, reactives: Array<KTReactive<any>>, options?: Partial<KTEffectOptions>): () => void;
-export {};

package/dist/reactive/index.d.ts

@@ -1,10 +0,0 @@
-import { KTReactive, ReactiveChangeHandler } from '../types/reactive.js';
-export declare const toReactive: <T>(value: T | KTReactive<T>, onChange?: ReactiveChangeHandler<T>) => KTReactive<T>;
-/**
- * Extracts the value from a KTReactive, or returns the value directly if it's not reactive.
- */
-export declare function dereactive<T = JSX.Element>(value: T | KTReactive<T>): T;
-export * from './core.js';
-export * from './ref.js';
-export * from './computed.js';
-export * from './effect.js';

package/dist/reactive/ref.d.ts

@@ -1,89 +0,0 @@
-import { KTReactive, ReactiveChangeHandler } from '../types/reactive.js';
-import { KTReactiveType } from './core.js';
-export declare class KTRef<T> implements KTReactive<T> {
-    /**
-     * Indicates that this is a KTRef instance
-     */
-    isKT: true;
-    ktType: KTReactiveType;
-    /**
-     * @internal
-     */
-    private _value;
-    /**
-     * @internal
-     */
-    private _onChanges;
-    /**
-     * @internal
-     */
-    private _emit;
-    constructor(_value: T, _onChanges: Array<ReactiveChangeHandler<T>>);
-    /**
-     * If new value and old value are both nodes, the old one will be replaced in the DOM
-     */
-    get value(): T;
-    set value(newValue: T);
-    /**
-     * Force all listeners to run even when reference identity has not changed.
-     * Useful for in-place array/object mutations.
-     */
-    notify(): void;
-    /**
-     * Mutate current value in-place and notify listeners once.
-     *
-     * @example
-     * const items = ref<number[]>([1, 2]);
-     * items.mutate((list) => list.push(3));
-     */
-    mutate<R = void>(mutator: (currentValue: T) => R): R;
-    /**
-     * Register a callback when the value changes
-     * @param callback (newValue, oldValue) => xxx
-     */
-    addOnChange(callback: ReactiveChangeHandler<T>): void;
-    removeOnChange(callback: ReactiveChangeHandler<T>): boolean;
-}
-/**
- * Reference to the created HTML element.
- * - **Only** respond to `ref.value` changes, not reactive to internal changes of the element.
- * - can alse be used to store normal values, but it is not reactive.
- * - if the value is already a `KTRef`, it will be returned **directly**.
- * @param value mostly an HTMLElement
- */
-export declare function ref<T = JSX.Element>(value?: T, onChange?: ReactiveChangeHandler<T>): KTRef<T>;
-/**
- * Convert a value to `KTRef`.
- * - Returns the original value if it is already a `KTRef`.
- * - Throws error if the value is a `KTComputed`.
- * - Otherwise wraps the value with `ref()`.
- * @param o value to convert
- */
-export declare const toRef: <T = any>(o: any) => KTRef<T>;
-export type KTSurfaceRef<T extends object> = {
-    [K in keyof T]: KTRef<T[K]>;
-} & {
-    /**
-     * Get the dereferenced object like the original one
-     */
-    kcollect: () => T;
-};
-/**
- * Make all first-level properties of the object a `KTRef`.
- * - `obj.a.b` is not reactive
- */
-export declare const surfaceRef: <T extends object>(obj: T) => KTSurfaceRef<T>;
-/**
- * Assert k-model to be a ref object
- */
-export declare const $modelOrRef: <T = any>(props: any, defaultValue?: T) => KTRef<T>;
-type RefSetter<T> = (props: {
-    ref?: KTRef<T>;
-}, node: T) => void;
-/**
- * Whether `props.ref` is a `KTRef` only needs to be checked in the initial render
- */
-export declare const $initRef: <T extends Node>(props: {
-    ref?: KTRef<T>;
-}, node: T) => RefSetter<T>;
-export {};