nine-9 1.8.1 → 1.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/dist/index.d.ts +96 -69
  2. package/dist/index.js +363 -120
  3. package/dist/index.js.map +1 -1
  4. package/dist/test.js +383 -143
  5. package/dist/test.js.map +1 -1
  6. package/package.json +1 -1
package/dist/index.d.ts CHANGED
@@ -17,16 +17,8 @@ type KebabToCamel<S extends string> = S extends `${infer First}-${infer Rest}` ?
17
17
  type ObjectToEntryUnion<T> = {
18
18
  [K in keyof T]: [K, T[K]];
19
19
  }[keyof T];
20
-
21
- type Wrapper<T> = {
22
- get(): T;
23
- set(newData: T): void;
24
- updateOnly(): void;
25
- event: EventSubcriber<[T, T]>;
26
- };
27
- declare function wrap<T>(initialData: T, wrapperOptions?: Partial<Wrapper<T>>): Wrapper<T>;
28
- declare function sync<R>(effectRenderer: () => R, dependencies?: unknown[]): Wrapper<R>;
29
- declare function when(condition: Wrapper<boolean> | (() => boolean), tree: () => SourceTree, dependencies?: unknown[]): Wrapper<SourceTree[]>;
20
+ type PutIntoIterable<T> = T extends unknown[] ? T : [T];
21
+ declare function defineTemplate<T = void>(): T;
30
22
 
31
23
  type StyleSet = {
32
24
  [K in keyof CSSStyleDeclaration]: (data: string) => StyleSet;
@@ -39,15 +31,18 @@ type StyleSet = {
39
31
  };
40
32
  declare function styleSet(selector?: string): StyleSet;
41
33
 
42
- type VueEventAttributes = keyof Events;
43
- type HTMLEventName<V extends string> = V extends `on${infer R extends string}` ? Uncapitalize<R> : never;
44
- type SupportedHTMLElements = keyof HTMLElementTagNameMap & keyof IntrinsicElementAttributes;
45
- type SupportedHTMLRawAttributes = {
46
- [K in SupportedHTMLElements]: Omit<IntrinsicElementAttributes[K], VueEventAttributes>;
47
- };
48
- type SupportedEventHandlerMap = {
49
- [K in VueEventAttributes as HTMLEventName<K>]: (event: Events[K]) => void;
34
+ type Wrapper<T> = {
35
+ get(): T;
36
+ set(newData: T): void;
37
+ updateOnly(): void;
38
+ event: EventSubcriber<[T, T]>;
50
39
  };
40
+ declare function normalizeWrap<T>(data: T | Wrapper<T>): Wrapper<T>;
41
+ declare function wrap<T>(initialState: T, wrapperOptions?: Partial<Wrapper<T>>): Wrapper<T>;
42
+
43
+ declare function sync<R>(effectRenderer: () => R, dependencies?: unknown[]): Wrapper<R>;
44
+
45
+ declare function when(condition: Wrapper<boolean> | (() => boolean), tree: () => SourceTree, dependencies?: unknown[]): Wrapper<SourceTree[]>;
51
46
 
52
47
  interface HostTreeHooks {
53
48
  treeUpdated: [newTrees: HostTree[], oldTrees: HostTree[]];
@@ -70,31 +65,27 @@ type HostTree<E extends SupportedHTMLElements = SupportedHTMLElements, T = HTMLE
70
65
  };
71
66
  declare function tree<E extends SupportedHTMLElements>(data: E | Node): HostTree<E, HTMLElementTagNameMap[E], SupportedHTMLRawAttributes[E]>;
72
67
 
73
- type RawSlotInput = SourceTree | (() => SourceTree);
74
- type SlotInput = RawSlotInput | Wrapper<RawSlotInput>;
75
- type SlotOutput = () => Wrapper<SourceTree>;
76
- declare function pipeExtract(input: SlotInput): SlotOutput;
68
+ type VueEventAttributes = keyof Events;
69
+ type HTMLEventName<V extends string> = V extends `on${infer R extends string}` ? Uncapitalize<R> : never;
70
+ type SupportedHTMLElements = keyof HTMLElementTagNameMap & keyof IntrinsicElementAttributes;
71
+ type SupportedHTMLRawAttributes = {
72
+ [K in SupportedHTMLElements]: Omit<IntrinsicElementAttributes[K], VueEventAttributes>;
73
+ };
74
+ type SupportedEventHandlerMap = {
75
+ [K in VueEventAttributes as HTMLEventName<K>]: (event: Events[K]) => void;
76
+ };
77
77
 
78
- type EventDescriptor<T, N extends string> = {
79
- name: N;
80
- } & EventOptions<T>;
81
- interface EventOptions<T> {
82
- bubbleable?: boolean;
83
- template?: T;
84
- }
85
- declare function defineEvent<T, N extends string>(name: N, options?: EventOptions<T>): EventDescriptor<T, N>;
78
+ declare function camelToHyphen<T extends string>(str: T): T;
79
+ declare function hyphenToCamel<T extends string>(str: T): T;
80
+
81
+ declare function typedIsArray<T>(arr: unknown[]): arr is T[];
82
+ declare function putIntoArray<T>(data: T): PutIntoIterable<T>;
83
+ declare function createArray<T>(length: number, filler: () => T): T[];
86
84
 
87
- interface ComponentRenderEntry<P extends ComponentPropertyStore, E extends ComponentEventStore> {
88
- (props?: ComponentPropertyInputDict<P>, slot?: SlotInput): ComponentInstance<E>;
89
- }
90
- interface ComponentInternalRender<P extends ComponentPropertyStore, E extends ComponentEventStore> {
91
- (options: ComponentPropertyOutputDict<P>, slot: SlotOutput, emit: <D extends E[number], K extends D["name"]>(key: K, data: D extends infer R extends EventDescriptor<unknown, string> ? R["name"] extends K ? R["template"] : never : never) => void): SourceTree;
92
- }
93
- type Component<P extends ComponentPropertyStore, E extends ComponentEventStore> = ComponentRenderEntry<P, E> & ComponentOption<P, E>;
94
85
  interface PropertyTransformer<I, O> {
95
86
  (data: I): O;
96
87
  }
97
- interface ComponentPropertyDescriptor<I = unknown, O = unknown, R extends boolean = boolean> {
88
+ interface PropertyDescriptor<I = unknown, O = unknown, R extends boolean = boolean> {
98
89
  validate?: (data: I) => boolean;
99
90
  transform: PropertyTransformer<I, O>;
100
91
  shadow?: O;
@@ -102,24 +93,72 @@ interface ComponentPropertyDescriptor<I = unknown, O = unknown, R extends boolea
102
93
  downloadable?: boolean;
103
94
  uploadable?: boolean;
104
95
  }
105
- type ComponentEventStore = EventDescriptor<unknown, string>[];
106
- type ComponentPropertyStore = Record<string, ComponentPropertyDescriptor>;
107
- type ComponentPropertyInputDict<P extends ComponentPropertyStore> = {
108
- [K in keyof P as P[K]["required"] extends true ? K : never]: P[K] extends ComponentPropertyDescriptor<unknown, infer R> ? R | Wrapper<R> : never;
96
+ type PropertyInputDict<P extends ComponentPropertyStore> = {
97
+ [K in keyof P as P[K]["required"] extends true ? K : never]: P[K] extends PropertyDescriptor<unknown, infer R> ? R | Wrapper<R> : never;
109
98
  } & {
110
- [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;
99
+ [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;
111
100
  };
112
- type ComponentPropertyOutputDict<P extends ComponentPropertyStore> = {
113
- [K in keyof P]: P[K] extends ComponentPropertyDescriptor<unknown, infer R> ? Wrapper<R> : never;
101
+ type PropertyOutputDict<P extends ComponentPropertyStore> = {
102
+ [K in keyof P]: P[K] extends PropertyDescriptor<unknown, infer R> ? Wrapper<R> : never;
103
+ };
104
+ declare function typed<T>(): PropertyTransformer<unknown, T>;
105
+ declare function normalizePropertyDescriptor<I, O, R extends boolean>(descriptor: PropertyDescriptor<I, O, R>): Required<PropertyDescriptor<I, O, R>>;
106
+ declare function validateStore(store: ComponentPropertyStore): void;
107
+ declare function hostdown<T extends ComponentPropertyStore>(upstream?: PropertyInputDict<T>, store?: T): PropertyOutputDict<T>;
108
+
109
+ type SlotDescriptor<T = unknown, N extends string = string, R extends boolean = boolean> = {
110
+ name: N;
111
+ } & SlotOptions<T, R>;
112
+ interface SlotOptions<T, R extends boolean> {
113
+ template: T;
114
+ required?: R;
115
+ defaultValue?: SourceTree;
116
+ }
117
+ type SlotInput<T> = (data: Wrapper<T>) => SourceTree | Wrapper<SourceTree>;
118
+ type SlotOutput<T> = (data: T | Wrapper<T>) => Wrapper<SourceTree>;
119
+ type SlotInputDict<T extends ComponentSlotStore> = {
120
+ [K in T[number] as K["name"]]?: SlotInput<K["template"]>;
121
+ };
122
+ type SlotOutputDict<T extends ComponentSlotStore> = {
123
+ [K in T[number] as K["name"]]-?: SlotOutput<K["template"]>;
124
+ };
125
+ declare function normalizeRenderer<T>(render: SlotInput<T>): SlotOutput<T>;
126
+ declare function renderSlots<T extends ComponentSlotStore>(rawInput?: SlotInputDict<T>, store?: T): SlotOutputDict<T>;
127
+ declare function defineSlot<N extends string, R extends boolean, T>(name: N, options: SlotOptions<T, R>): {
128
+ template: T;
129
+ required?: R | undefined;
130
+ defaultValue?: SourceTree;
131
+ name: N;
114
132
  };
115
- interface ComponentOption<P extends ComponentPropertyStore, E extends ComponentEventStore> {
133
+
134
+ type EventDescriptor<T = unknown, N extends string = string> = {
135
+ name: N;
136
+ } & EventOptions<T>;
137
+ interface EventOptions<T> {
138
+ bubbleable?: boolean;
139
+ template?: T;
140
+ }
141
+ declare function defineEvent<T, N extends string>(name: N, options?: EventOptions<T>): EventDescriptor<T, N>;
142
+
143
+ interface ComponentRenderEntry<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
144
+ (props?: PropertyInputDict<P>, slot?: SlotInputDict<S>): ComponentInstance<E>;
145
+ }
146
+ interface ComponentInternalRender<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
147
+ (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;
148
+ }
149
+ type Component<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> = ComponentRenderEntry<P, E, S> & ComponentOption<P, E, S>;
150
+ type ComponentPropertyStore = Record<string, PropertyDescriptor>;
151
+ type ComponentEventStore = EventDescriptor[];
152
+ type ComponentSlotStore = SlotDescriptor[];
153
+ interface ComponentOption<P extends ComponentPropertyStore, E extends ComponentEventStore, S extends ComponentSlotStore> {
116
154
  props?: P;
117
155
  events?: E;
118
156
  styles?: StyleSet[];
157
+ slots?: S;
119
158
  }
120
159
  type ComponentInstance<E extends ComponentEventStore = ComponentEventStore> = {
121
160
  mount(to: string | HTMLElement): void;
122
- on<D extends E[number], K extends D["name"]>(key: K, data: (data: D extends infer R extends EventDescriptor<unknown, string> ? R["name"] extends K ? R["template"] : never : never) => void): ComponentInstance<E>;
161
+ on<D extends E[number], K extends D["name"]>(key: K, data: (data: D extends infer R extends EventDescriptor ? R["name"] extends K ? R["template"] : never : never) => void): ComponentInstance<E>;
123
162
  $: HostTree;
124
163
  };
125
164
  type RawSourceTree = [
@@ -136,19 +175,7 @@ declare function render(nodeTree: SourceTree): HostTree;
136
175
  declare function $<T>(data: Wrapper<T>): Wrapper<SourceTree>;
137
176
  declare function flagment<T extends string>(uuid: T): `nine_${string}`;
138
177
  declare function attachUUID(root: Node, uuid: string): Node;
139
- declare function createComponent<P extends ComponentPropertyStore, E extends EventDescriptor<unknown, string>>(options: ComponentOption<P, E[]>, internalRenderer: ComponentInternalRender<P, E[]>): Component<P, E[]>;
140
-
141
- declare function rawProperty<T>(): PropertyTransformer<unknown, T>;
142
- declare function normalizePropertyDescriptor<I, O, R extends boolean>(descriptor: ComponentPropertyDescriptor<I, O, R>): Required<ComponentPropertyDescriptor<I, O, R>>;
143
- declare function validateStore(store: ComponentPropertyStore): void;
144
- declare function hostdown<T extends ComponentPropertyStore>(upstream?: ComponentPropertyInputDict<T>, store?: T): ComponentPropertyOutputDict<T>;
145
-
146
- declare function camelToHyphen<T extends string>(str: T): T;
147
- declare function hyphenToCamel<T extends string>(str: T): T;
148
-
149
- declare function typedIsArray<T>(arr: unknown[]): arr is T[];
150
- declare function putIntoArray<T>(data: T): T extends (infer R)[] ? R[] : [T];
151
- declare function createArray<T>(length: number, filler: () => T): T[];
178
+ declare function createComponent<P extends ComponentPropertyStore, E extends EventDescriptor, S extends SlotDescriptor>(options: ComponentOption<P, E[], S[]>, internalRenderer: ComponentInternalRender<P, E[], S[]>): Component<P, E[], S[]>;
152
179
 
153
180
  declare namespace logo {
154
181
  export { };
@@ -169,13 +196,7 @@ declare const _default: {
169
196
  downloadable: true;
170
197
  uploadable: true;
171
198
  };
172
- }, (EventDescriptor<{
173
- arg1: number;
174
- arg2: boolean;
175
- }, "up"> | EventDescriptor<{
176
- arg3: string;
177
- arg4: symbol;
178
- }, "down">)[]>;
199
+ }, (EventDescriptor<string, "up"> | EventDescriptor<number, "down">)[], SlotDescriptor[]>;
179
200
  Selector: Component<{
180
201
  items: {
181
202
  transform: PropertyTransformer<unknown, string[]>;
@@ -186,7 +207,13 @@ declare const _default: {
186
207
  uploadable: true;
187
208
  required: true;
188
209
  };
189
- }, (EventDescriptor<number, "select"> | EventDescriptor<boolean, "toggleState">)[]>;
210
+ }, (EventDescriptor<number, "select"> | EventDescriptor<boolean, "toggleState">)[], {
211
+ template: string;
212
+ required?: boolean | undefined;
213
+ defaultValue?: SourceTree;
214
+ name: "title";
215
+ }[]>;
216
+ ObjectWatcher: Component<ComponentPropertyStore, EventDescriptor[], SlotDescriptor[]>;
190
217
  };
191
218
 
192
- export { $, type Component, type ComponentEventStore, type ComponentInstance, type ComponentInternalRender, type ComponentOption, type ComponentPropertyDescriptor, type ComponentPropertyInputDict, type ComponentPropertyOutputDict, type ComponentPropertyStore, type ComponentRenderEntry, type EmptyValue, type EventDescriptor, type EventOptions, EventSubcriber, type HostTree, type HostTreeHookStore, type HostTreeHooks, type KebabToCamel, type Normalize, type ObjectToEntryUnion, type PropertyTransformer, type RawSlotInput, type RawSourceTree, type SlotInput, type SlotOutput, type SourceTree, type StyleSet, type Valueof, type Wrapper, index as assets, attachUUID, camelToHyphen, createArray, createComponent, defineEvent, _default as examples, flagment, hostdown, hyphenToCamel, normalizePropertyDescriptor, pipeExtract, putIntoArray, rawProperty, render, styleSet, sync, tree, typedIsArray, validateStore, when, wrap };
219
+ 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 };