nine-9 1.9.0 → 1.11.0

package/dist/index.d.ts

@@ -17,19 +17,9 @@ type KebabToCamel<S extends string> = S extends `${infer First}-${infer Rest}` ?
 type ObjectToEntryUnion<T> = {
     [K in keyof T]: [K, T[K]];
 }[keyof T];
+type PutIntoIterable<T> = T extends unknown[] ? T : [T];
 declare function defineTemplate<T = void>(): T;
 
-type Wrapper<T> = {
-    get(): T;
-    set(newData: T): void;
-    updateOnly(): void;
-    event: EventSubcriber<[T, T]>;
-};
-declare function normalizeWrap<T>(data: T | Wrapper<T>): Wrapper<T>;
-declare function wrap<T>(initialData: T, wrapperOptions?: Partial<Wrapper<T>>): Wrapper<T>;
-declare function sync<R>(effectRenderer: () => R, dependencies?: unknown[]): Wrapper<R>;
-declare function when(condition: Wrapper<boolean> | (() => boolean), tree: () => SourceTree, dependencies?: unknown[]): Wrapper<SourceTree[]>;
-
 type StyleSet = {
     [K in keyof CSSStyleDeclaration]: (data: string) => StyleSet;
 } & {
@@ -41,15 +31,18 @@ type StyleSet = {
 };
 declare function styleSet(selector?: string): StyleSet;
 
-type VueEventAttributes = keyof Events;
-type HTMLEventName<V extends string> = V extends `on${infer R extends string}` ? Uncapitalize<R> : never;
-type SupportedHTMLElements = keyof HTMLElementTagNameMap & keyof IntrinsicElementAttributes;
-type SupportedHTMLRawAttributes = {
-    [K in SupportedHTMLElements]: Omit<IntrinsicElementAttributes[K], VueEventAttributes>;
-};
-type SupportedEventHandlerMap = {
-    [K in VueEventAttributes as HTMLEventName<K>]: (event: Events[K]) => void;
+type Wrapper<T> = {
+    get(): T;
+    set(newData: T): void;
+    updateOnly(): void;
+    event: EventSubcriber<[T, T]>;
 };
+declare function normalizeWrap<T>(data: T | Wrapper<T>): Wrapper<T>;
+declare function wrap<T>(initialState: T, wrapperOptions?: Partial<Wrapper<T>>): Wrapper<T>;
+
+declare function sync<R>(effectRenderer: () => R, dependencies?: unknown[]): Wrapper<R>;
+
+declare function when(condition: Wrapper<boolean> | (() => boolean), tree: () => SourceTree, dependencies?: unknown[]): Wrapper<SourceTree[]>;
 
 interface HostTreeHooks {
     treeUpdated: [newTrees: HostTree[], oldTrees: HostTree[]];
@@ -72,14 +65,27 @@ type HostTree<E extends SupportedHTMLElements = SupportedHTMLElements, T = HTMLE
 };
 declare function tree<E extends SupportedHTMLElements>(data: E | Node): HostTree<E, HTMLElementTagNameMap[E], SupportedHTMLRawAttributes[E]>;
 
+type VueEventAttributes = keyof Events;
+type HTMLEventName<V extends string> = V extends `on${infer R extends string}` ? Uncapitalize<R> : never;
+type SupportedHTMLElements = keyof HTMLElementTagNameMap & keyof IntrinsicElementAttributes;
+type SupportedHTMLRawAttributes = {
+    [K in SupportedHTMLElements]: Omit<IntrinsicElementAttributes[K], VueEventAttributes>;
+};
+type SupportedEventHandlerMap = {
+    [K in VueEventAttributes as HTMLEventName<K>]: (event: Events[K]) => void;
+};
+
 declare function camelToHyphen<T extends string>(str: T): T;
 declare function hyphenToCamel<T extends string>(str: T): T;
 
 declare function typedIsArray<T>(arr: unknown[]): arr is T[];
-declare function putIntoArray<T>(data: T): T extends (infer R)[] ? R[] : [T];
+declare function putIntoArray<T>(data: T): PutIntoIterable<T>;
 declare function createArray<T>(length: number, filler: () => T): T[];
 
-interface ComponentPropertyDescriptor<I = unknown, O = unknown, R extends boolean = boolean> {
+interface PropertyTransformer<I, O> {
+    (data: I): O;
+}
+interface PropertyDescriptor<I = unknown, O = unknown, R extends boolean = boolean> {
     validate?: (data: I) => boolean;
     transform: PropertyTransformer<I, O>;
     shadow?: O;
@@ -87,18 +93,18 @@ interface ComponentPropertyDescriptor<I = unknown, O = unknown, R extends boolea
     downloadable?: boolean;
     uploadable?: boolean;
 }
-type ComponentPropertyInputDict<P extends ComponentPropertyStore> = {
-    [K in keyof P as P[K]["required"] extends true ? K : never]: P[K] extends ComponentPropertyDescriptor<unknown, infer R> ? R | Wrapper<R> : never;
+type PropertyInputDict<P extends ComponentPropertyStore> = {
+    [K in keyof P as P[K]["required"] extends true ? K : never]: P[K] extends PropertyDescriptor<unknown, infer R> ? R | Wrapper<R> : never;
 } & {
-    [K in keyof P as P[K]["required"] extends false | unknown ? K : never]?: P[K] extends ComponentPropertyDescriptor<unknown, infer R> ? R | Wrapper<R> | EmptyValue : never;
+    [K in keyof P as P[K]["required"] extends false | unknown ? K : never]?: P[K] extends PropertyDescriptor<unknown, infer R> ? R | Wrapper<R> | EmptyValue : never;
 };
-type ComponentPropertyOutputDict<P extends ComponentPropertyStore> = {
-    [K in keyof P]: P[K] extends ComponentPropertyDescriptor<unknown, infer R> ? Wrapper<R> : never;
+type PropertyOutputDict<P extends ComponentPropertyStore> = {
+    [K in keyof P]: P[K] extends PropertyDescriptor<unknown, infer R> ? Wrapper<R> : never;
 };
-declare function rawProperty<T>(): PropertyTransformer<unknown, T>;
-declare function normalizePropertyDescriptor<I, O, R extends boolean>(descriptor: ComponentPropertyDescriptor<I, O, R>): Required<ComponentPropertyDescriptor<I, O, R>>;
+declare function typed<T>(): PropertyTransformer<unknown, T>;
+declare function normalizePropertyDescriptor<I, O, R extends boolean>(descriptor: PropertyDescriptor<I, O, R>): Required<PropertyDescriptor<I, O, R>>;
 declare function validateStore(store: ComponentPropertyStore): void;
-declare function hostdown<T extends ComponentPropertyStore>(upstream?: ComponentPropertyInputDict<T>, store?: T): ComponentPropertyOutputDict<T>;
+declare function hostdown<T extends ComponentPropertyStore>(upstream?: PropertyInputDict<T>, store?: T): PropertyOutputDict<T>;
 
 type SlotDescriptor<T = unknown, N extends string = string, R extends boolean = boolean> = {
     name: N;
@@ -110,14 +116,14 @@ interface SlotOptions<T, R extends boolean> {
 }
 type SlotInput<T> = (data: Wrapper<T>) => SourceTree | Wrapper<SourceTree>;
 type SlotOutput<T> = (data: T | Wrapper<T>) => Wrapper<SourceTree>;
-type ComponentSlotInputDict<T extends ComponentSlotStore> = {
+type SlotInputDict<T extends ComponentSlotStore> = {
     [K in T[number] as K["name"]]?: SlotInput<K["template"]>;
 };
-type ComponentSlotOutputDict<T extends ComponentSlotStore> = {
+type SlotOutputDict<T extends ComponentSlotStore> = {
     [K in T[number] as K["name"]]-?: SlotOutput<K["template"]>;
 };
-declare function extractInput<T>(render: SlotInput<T>): SlotOutput<T>;
-declare function renderSlots<T extends ComponentSlotStore>(rawInput?: ComponentSlotInputDict<T>, store?: T): ComponentSlotOutputDict<T>;
+declare function normalizeRenderer<T>(render: SlotInput<T>): SlotOutput<T>;
+declare function renderSlots<T extends ComponentSlotStore>(rawInput?: SlotInputDict<T>, store?: T): SlotOutputDict<T>;
 declare function defineSlot<N extends string, R extends boolean, T>(name: N, options: SlotOptions<T, R>): {
     template: T;
     required?: R | undefined;
@@ -135,16 +141,13 @@ interface EventOptions<T> {
 declare function defineEvent<T, N extends string>(name: N, options?: EventOptions<T>): EventDescriptor<T, N>;
 
 interface ComponentRenderEntry<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
-    (props?: ComponentPropertyInputDict<P>, slot?: ComponentSlotInputDict<S>): ComponentInstance<E>;
+    (props?: PropertyInputDict<P>, slot?: SlotInputDict<S>): ComponentInstance<E>;
 }
 interface ComponentInternalRender<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
-    (options: ComponentPropertyOutputDict<P>, slot: ComponentSlotOutputDict<S>, emit: <D extends E[number], K extends D["name"]>(key: K, data: D extends infer R extends EventDescriptor ? R["name"] extends K ? R["template"] : never : never) => void): SourceTree;
+    (options: PropertyOutputDict<P>, slot: SlotOutputDict<S>, emit: <D extends E[number], K extends D["name"]>(key: K, data: D extends infer R extends EventDescriptor ? R["name"] extends K ? R["template"] : never : never) => void): SourceTree;
 }
 type Component<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> = ComponentRenderEntry<P, E, S> & ComponentOption<P, E, S>;
-interface PropertyTransformer<I, O> {
-    (data: I): O;
-}
-type ComponentPropertyStore = Record<string, ComponentPropertyDescriptor>;
+type ComponentPropertyStore = Record<string, PropertyDescriptor>;
 type ComponentEventStore = EventDescriptor[];
 type ComponentSlotStore = SlotDescriptor[];
 interface ComponentOption<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
@@ -193,13 +196,7 @@ declare const _default: {
             downloadable: true;
             uploadable: true;
         };
-    }, (EventDescriptor<{
-        arg1: number;
-        arg2: boolean;
-    }, "up"> | EventDescriptor<{
-        arg3: string;
-        arg4: symbol;
-    }, "down">)[]>;
+    }, (EventDescriptor<string, "up"> | EventDescriptor<number, "down">)[], SlotDescriptor[]>;
     Selector: Component<{
         items: {
             transform: PropertyTransformer<unknown, string[]>;
@@ -210,7 +207,13 @@ declare const _default: {
             uploadable: true;
             required: true;
         };
-    }, (EventDescriptor<number, "select"> | EventDescriptor<boolean, "toggleState">)[]>;
+    }, (EventDescriptor<number, "select"> | EventDescriptor<boolean, "toggleState">)[], {
+        template: string;
+        required?: boolean | undefined;
+        defaultValue?: SourceTree;
+        name: "title";
+    }[]>;
+    ObjectWatcher: Component<ComponentPropertyStore, EventDescriptor[], SlotDescriptor[]>;
 };
 
-export { $, type Component, type ComponentEventStore, type ComponentInstance, type ComponentInternalRender, type ComponentOption, type ComponentPropertyDescriptor, type ComponentPropertyInputDict, type ComponentPropertyOutputDict, type ComponentPropertyStore, type ComponentRenderEntry, type ComponentSlotInputDict, type ComponentSlotOutputDict, type ComponentSlotStore, type EmptyValue, type EventDescriptor, type EventOptions, EventSubcriber, type HostTree, type HostTreeHookStore, type HostTreeHooks, type KebabToCamel, type Normalize, type ObjectToEntryUnion, type PropertyTransformer, type RawSourceTree, type SlotDescriptor, type SlotInput, type SlotOptions, type SlotOutput, type SourceTree, type StyleSet, type Valueof, type Wrapper, index as assets, attachUUID, camelToHyphen, createArray, createComponent, defineEvent, defineSlot, defineTemplate, _default as examples, extractInput, flagment, hostdown, hyphenToCamel, normalizePropertyDescriptor, normalizeWrap, putIntoArray, rawProperty, render, renderSlots, styleSet, sync, tree, typedIsArray, validateStore, when, wrap };
+export { $, type Component, type ComponentEventStore, type ComponentInstance, type ComponentInternalRender, type ComponentOption, type ComponentPropertyStore, type ComponentRenderEntry, type ComponentSlotStore, type EmptyValue, type EventDescriptor, type EventOptions, EventSubcriber, type HostTree, type HostTreeHookStore, type HostTreeHooks, type KebabToCamel, type Normalize, type ObjectToEntryUnion, type PropertyDescriptor, type PropertyInputDict, type PropertyOutputDict, type PropertyTransformer, type PutIntoIterable, type RawSourceTree, type SlotDescriptor, type SlotInput, type SlotInputDict, type SlotOptions, type SlotOutput, type SlotOutputDict, type SourceTree, type StyleSet, type SupportedEventHandlerMap, type SupportedHTMLElements, type SupportedHTMLRawAttributes, type Valueof, type Wrapper, index as assets, attachUUID, camelToHyphen, createArray, createComponent, defineEvent, defineSlot, defineTemplate, _default as examples, flagment, hostdown, hyphenToCamel, normalizePropertyDescriptor, normalizeRenderer, normalizeWrap, putIntoArray, render, renderSlots, styleSet, sync, tree, typed, typedIsArray, validateStore, when, wrap };