@ktjs/core 0.29.6 → 0.29.8

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

@@ -0,0 +1,6 @@
+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

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

package/dist/h/content.d.ts

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

package/dist/h/index.d.ts

@@ -0,0 +1,12 @@
+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

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

package/dist/index.d.ts

@@ -1,428 +1,10 @@
-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 { }
+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';