ilha 0.0.1 → 0.1.0

package/dist/index.d.ts

@@ -37,18 +37,18 @@ interface RawHtml {
   [RAW]: true;
   value: string;
 }
-interface SlotAccessor {
-  (props?: Record<string, unknown>): RawHtml;
+interface SlotAccessor<TProps = Record<string, unknown>> {
+  (props?: TProps): RawHtml;
   toString(): string;
   [SLOT_ACCESSOR]: true;
 }
 interface MarkedSignalAccessor<T> {
   (): T;
-  (value: T): void;
+  (...args: [value: T]): void;
   [SIGNAL_ACCESSOR]: true;
 }
 declare function ilhaRaw(value: string): RawHtml;
-declare function ilhaHtml(strings: TemplateStringsArray, ...values: unknown[]): string;
+declare function ilhaHtml(strings: TemplateStringsArray, ...values: unknown[]): RawHtml;
 type ContextSignal<T> = {
   (): T;
   (value: T): void;
@@ -70,20 +70,36 @@ interface DerivedEntry<TInput, TStateMap extends Record<string, unknown>> {
   fn: DerivedFn<TInput, TStateMap, unknown>;
 }
 type IslandDerived<TDerivedMap extends Record<string, unknown>> = { readonly [K in keyof TDerivedMap]: DerivedValue<TDerivedMap[K]> };
+type ExternalSignal<T = unknown> = {
+  (): T;
+  (value: T): void;
+};
 interface BindEntry<TStateMap extends Record<string, unknown>> {
   selector: string;
-  stateKey: keyof TStateMap & string;
+  target: (keyof TStateMap & string) | ExternalSignal;
 }
 type SignalAccessor<T> = MarkedSignalAccessor<T>;
-type IslandState<TStateMap extends Record<string, unknown>> = { [K in keyof TStateMap]: SignalAccessor<TStateMap[K]> };
-interface Island<TInput, TStateMap extends Record<string, unknown>> {
+type MergeState<TStateMap extends Record<string, unknown>, K extends string, V> = { [P in keyof TStateMap as P extends K ? never : P]-?: TStateMap[P] } & Record<K, V>;
+type IslandState<TStateMap extends Record<string, unknown>> = { readonly [K in keyof TStateMap]-?: SignalAccessor<TStateMap[K]> };
+interface HydratableOptions {
+  name: string;
+  as?: string;
+  snapshot?: boolean | {
+    state?: boolean;
+    derived?: boolean;
+  };
+  skipOnMount?: boolean;
+}
+interface Island<TInput = Record<string, unknown>, _TStateMap extends Record<string, unknown> = Record<string, unknown>> {
   (props?: Partial<TInput>): string | Promise<string>;
   toString(props?: Partial<TInput>): string;
-  mount(el: Element, props?: Partial<TInput>): () => void;
+  mount(host: Element, props?: Partial<TInput>): () => void;
+  hydratable(props: Partial<TInput>, options: HydratableOptions): Promise<string>;
 }
-type AnyIsland = Island<Record<string, unknown>, Record<string, unknown>>;
+type InferIslandInput<T> = T extends Island<infer TInput, any> ? TInput : Record<string, unknown>;
+type AnyIsland = Island<any, any>;
 type SlotMap = Record<string, AnyIsland>;
-type SlotsProxy<TSlots extends SlotMap> = { readonly [K in keyof TSlots]: SlotAccessor };
+type SlotsProxy<TSlots extends SlotMap> = { readonly [K in keyof TSlots]: SlotAccessor<Partial<InferIslandInput<TSlots[K]>>> };
 type RenderContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>, TSlots extends SlotMap> = {
   state: IslandState<TStateMap>;
   derived: IslandDerived<TDerivedMap>;
@@ -93,59 +109,89 @@ type RenderContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMa
 type EffectContext<TInput, TStateMap extends Record<string, unknown>> = {
   state: IslandState<TStateMap>;
   input: TInput;
-  el: Element;
+  host: Element;
 };
-type HandlerContext<TInput, TStateMap extends Record<string, unknown>> = {
+type OnMountContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<string, never>> = {
   state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
   input: TInput;
-  el: Element;
+  host: Element;
+  hydrated: boolean;
+};
+type HandlerContext<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<string, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  target: Element;
   event: Event;
 };
+type HTMLEventName = keyof HTMLElementEventMap & string;
+type Modifier = "once" | "capture" | "passive";
+type WithModifiers<E extends string> = E | `${E}:${Modifier}` | `${E}:${Modifier}:${Modifier}` | `${E}:${Modifier}:${Modifier}:${Modifier}`;
+type OnSelectorString = `@${WithModifiers<HTMLEventName>}` | `${string}@${WithModifiers<HTMLEventName>}`;
+type HandlerContextFor<TInput, TStateMap extends Record<string, unknown>, TEventName extends string, TDerivedMap extends Record<string, unknown> = Record<string, never>> = {
+  state: IslandState<TStateMap>;
+  derived: IslandDerived<TDerivedMap>;
+  input: TInput;
+  host: Element;
+  target: TEventName extends keyof HTMLElementEventMap ? HTMLElementEventMap[TEventName]["target"] extends Element | null ? NonNullable<HTMLElementEventMap[TEventName]["target"]> : Element : Element;
+  event: TEventName extends keyof HTMLElementEventMap ? HTMLElementEventMap[TEventName] : Event;
+};
 type StateInit<TInput, V> = V | ((input: TInput) => V);
 interface StateEntry<TInput> {
   key: string;
   init: StateInit<TInput, unknown>;
 }
-interface OnEntry<TInput, TStateMap extends Record<string, unknown>> {
+interface OnEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<string, never>> {
   selector: string;
   event: string;
   options: AddEventListenerOptions;
-  handler: (ctx: HandlerContext<TInput, TStateMap>) => void | Promise<void>;
+  handler: (ctx: HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>;
 }
 interface EffectEntry<TInput, TStateMap extends Record<string, unknown>> {
   fn: (ctx: EffectContext<TInput, TStateMap>) => (() => void) | void;
 }
+interface OnMountEntry<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>> {
+  fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void;
+}
 interface TransitionOptions {
-  enter?: (el: Element) => Promise<void> | void;
-  leave?: (el: Element) => Promise<void> | void;
+  enter?: (host: Element) => Promise<void> | void;
+  leave?: (host: Element) => Promise<void> | void;
 }
 interface MountOptions {
   root?: Element;
-  hydrate?: boolean;
   lazy?: boolean;
 }
 interface MountResult {
   unmount: () => void;
 }
+interface BuilderConfig<TInput, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown>, _TSlots extends SlotMap> {
+  schema: StandardSchemaV1 | null;
+  states: StateEntry<TInput>[];
+  deriveds: DerivedEntry<TInput, TStateMap>[];
+  ons: OnEntry<TInput, TStateMap, TDerivedMap>[];
+  effects: EffectEntry<TInput, TStateMap>[];
+  onMounts: OnMountEntry<TInput, TStateMap, TDerivedMap>[];
+  slots: Record<string, AnyIsland>;
+  transition: TransitionOptions | null;
+  binds: BindEntry<TStateMap>[];
+}
 declare class IlhaBuilder<TInput extends Record<string, unknown>, TStateMap extends Record<string, unknown>, TDerivedMap extends Record<string, unknown> = Record<string, never>, TSlots extends SlotMap = Record<string, never>> {
-  private readonly _schema;
-  private readonly _states;
-  private readonly _deriveds;
-  private readonly _ons;
-  private readonly _effects;
-  private readonly _slots;
-  private readonly _transition;
-  private readonly _binds;
-  constructor(_schema: StandardSchemaV1 | null, _states: StateEntry<TInput>[], _deriveds: DerivedEntry<TInput, TStateMap>[], _ons: OnEntry<TInput, TStateMap>[], _effects: EffectEntry<TInput, TStateMap>[], _slots: Record<string, AnyIsland>, _transition: TransitionOptions | null, _binds: BindEntry<TStateMap>[]);
+  readonly _cfg: BuilderConfig<TInput, TStateMap, TDerivedMap, TSlots>;
+  constructor(cfg: BuilderConfig<TInput, TStateMap, TDerivedMap, TSlots>);
   input<S extends StandardSchemaV1>(schema: S): IlhaBuilder<StandardSchemaV1.InferOutput<S> & Record<string, unknown>, Record<string, never>, Record<string, never>, Record<string, never>>;
-  state<K extends string, V>(key: K, init: StateInit<TInput, V>): IlhaBuilder<TInput, TStateMap & Record<K, V>, TDerivedMap, TSlots>;
+  state<V = undefined, K extends string = string>(key: K, init?: StateInit<TInput, V> | undefined): IlhaBuilder<TInput, MergeState<TStateMap, K, V>, TDerivedMap, TSlots>;
   derived<K extends string, V>(key: K, fn: DerivedFn<TInput, TStateMap, V>): IlhaBuilder<TInput, TStateMap, TDerivedMap & Record<K, V>, TSlots>;
   bind(selector: string, stateKey: keyof TStateMap & string): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
-  on(selectorOrCombined: string, callbackOrEventType: ((ctx: HandlerContext<TInput, TStateMap>) => void | Promise<void>) | string, handler?: (ctx: HandlerContext<TInput, TStateMap>) => void | Promise<void>): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
+  bind<T>(selector: string, externalSignal: ExternalSignal<T>): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
+  on<S extends OnSelectorString>(selectorOrCombined: S, handler: (ctx: S extends `${string}@${infer E}:${string}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : S extends `${string}@${infer E}` ? HandlerContextFor<TInput, TStateMap, E, TDerivedMap> : HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
+  on(selectorOrCombined: string, handler: (ctx: HandlerContext<TInput, TStateMap, TDerivedMap>) => void | Promise<void>): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
   effect(fn: (ctx: EffectContext<TInput, TStateMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
-  slot<K extends string>(name: K, island: AnyIsland): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots & Record<K, AnyIsland>>;
+  onMount(fn: (ctx: OnMountContext<TInput, TStateMap, TDerivedMap>) => (() => void) | void): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
+  slot<K extends string, I extends AnyIsland>(name: K, island: I): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots & Record<K, I>>;
   transition(opts: TransitionOptions): IlhaBuilder<TInput, TStateMap, TDerivedMap, TSlots>;
-  render(fn: (ctx: RenderContext<TInput, TStateMap, TDerivedMap, TSlots>) => string): Island<TInput, TStateMap>;
+  render(fn: (ctx: RenderContext<TInput, TStateMap, TDerivedMap, TSlots>) => string | RawHtml): Island<TInput, TStateMap>;
 }
 declare function ilhaFrom<TInput, TStateMap extends Record<string, unknown>>(selector: string | Element, island: Island<TInput, TStateMap>, props?: Partial<TInput>): (() => void) | null;
 type IslandRegistry = Record<string, AnyIsland>;
@@ -157,10 +203,11 @@ declare const ilha: IlhaBuilder<Record<string, unknown>, Record<string, never>,
   from: typeof ilhaFrom;
   context: typeof ilhaContext;
 };
+declare function type<TInput, TOutput = TInput>(coerce?: (input: TInput) => TOutput): StandardSchemaV1<TInput, TOutput>;
 declare const html: typeof ilhaHtml;
 declare const raw: typeof ilhaRaw;
 declare const mount: typeof mountAll;
 declare const from: typeof ilhaFrom;
 declare const context: typeof ilhaContext;
 //#endregion
-export { DerivedValue, HandlerContext, Island, IslandDerived, IslandState, MountOptions, MountResult, SignalAccessor, SlotAccessor, context, ilha as default, from, html, mount, raw };
+export { DerivedValue, HandlerContext, HandlerContextFor, HydratableOptions, Island, IslandDerived, IslandState, MountOptions, MountResult, OnMountContext, RawHtml, SignalAccessor, SlotAccessor, context, ilha as default, from, html, mount, raw, type };