kiru 0.44.4

package/src/form/types.ts

@@ -0,0 +1,261 @@
+type ObjectValuesArray<T extends object> = T[keyof T][]
+
+type IsObject<T> = T extends object ? (T extends any[] ? false : true) : false
+
+type InferKeyWithIndices<T, Prefix extends string = ""> = {
+  [K in keyof T & string]: T[K] extends Array<infer U> | undefined
+    ? IsObject<U> extends true
+      ? // If it's an array of objects, infer the index and recurse into the object properties
+        | `${Prefix}${K}`
+          | `${Prefix}${K}.${number}`
+          | InferKeyWithIndices<U, `${Prefix}${K}.${number}.`>
+      : `${Prefix}${K}` | `${Prefix}${K}.${number}` // For arrays of primitives, only support indices
+    : IsObject<T[K]> extends true
+    ? // If it's an object, recurse into its properties
+      `${Prefix}${K}` | InferKeyWithIndices<T[K], `${Prefix}${K}.`>
+    : `${Prefix}${K}` // If it's a primitive, return the key
+}[keyof T & string]
+
+export type RecordKey<T extends Record<string, unknown>> =
+  InferKeyWithIndices<T>
+
+type InferValue<
+  T,
+  Path extends string
+> = Path extends `${infer K}.${infer Rest}`
+  ? K extends keyof T
+    ? InferValue<T[K], Rest> // Recursively resolve objects
+    : K extends `${number}` // Check if it's a numeric index for an array
+    ? T extends Array<infer U> | undefined
+      ? InferValue<U, Rest> // Recursively resolve array elements
+      : never
+    : never
+  : Path extends keyof T
+  ? T[Path] // Direct lookup for simple keys
+  : Path extends `${number}` // If the path is numeric (array index)
+  ? T extends Array<infer U> | undefined
+    ? U // Resolve the array element type
+    : never
+  : never
+
+export type InferRecordKeyValue<
+  T extends Record<string, unknown>,
+  K extends RecordKey<T>
+> = InferValue<T, K>
+
+export type ValidatorContext<T> = {
+  value: T
+}
+
+type FormFieldValidator<T extends unknown> = (
+  context: ValidatorContext<T>
+) => any
+
+export type AsyncValidatorContext<T> = {
+  value: T
+  abortSignal: AbortSignal
+}
+
+type AsyncFormFieldValidator<T extends unknown> = (
+  context: AsyncValidatorContext<T>
+) => Promise<any>
+
+export type FormFieldValidators<RecordKey extends string, Value> = {
+  dependentOn: RecordKey[]
+  onBlur: FormFieldValidator<Value>
+  onChange: FormFieldValidator<Value>
+  onChangeAsyncDebounceMs: number
+  onChangeAsync: AsyncFormFieldValidator<Value>
+  onMount: FormFieldValidator<Value>
+  onSubmit: FormFieldValidator<Value>
+}
+
+type Falsy = false | null | undefined
+
+type InferValidatorReturn<T> = T extends Falsy
+  ? never
+  : T extends Promise<infer U>
+  ? InferValidatorReturn<U>
+  : T
+
+type InferFormFieldErrors<
+  RecordKey extends string,
+  T extends FormFieldValidators<RecordKey, any>
+> = ObjectValuesArray<{
+  [K in keyof T]: T[K] extends FormFieldValidator<any>
+    ? InferValidatorReturn<ReturnType<T[K]>>
+    : never
+}>
+
+export type FormFieldContext<
+  T extends Record<string, unknown>,
+  Name extends RecordKey<T>,
+  Validators extends FormFieldValidators<
+    RecordKey<T>,
+    InferRecordKeyValue<T, Name>
+  >,
+  IsArray extends Boolean
+> = {
+  name: Name
+  state: {
+    value: InferRecordKeyValue<T, Name>
+    errors: InferFormFieldErrors<RecordKey<T>, Validators>
+    isTouched: boolean
+    isValidating: boolean
+  }
+  handleChange: (value: InferRecordKeyValue<T, Name>) => void
+  handleBlur: () => void
+} & (IsArray extends true
+  ? {
+      items: {
+        replace: (
+          index: number,
+          value: InferRecordKeyValue<T, Name> extends Array<infer U> ? U : any
+        ) => void
+        push: (
+          value: InferRecordKeyValue<T, Name> extends Array<infer U> ? U : any
+        ) => void
+        remove: (index: number) => void
+      }
+    }
+  : {})
+
+export type AnyFormFieldContext<
+  T extends Record<string, any> = Record<string, any>
+> = FormFieldContext<T, any, any, any>
+
+export type FormFieldState<
+  T extends Record<string, any>,
+  K extends RecordKey<T>
+> = {
+  value: InferRecordKeyValue<T, K>
+  errors: InferFormFieldErrors<
+    K,
+    FormFieldValidators<K, InferRecordKeyValue<T, K>>
+  >
+  isTouched: boolean
+  isValidating: boolean
+}
+
+export type FormFieldProps<
+  T extends Record<string, unknown>,
+  Name extends RecordKey<T>,
+  Validators extends FormFieldValidators<
+    RecordKey<T>,
+    InferRecordKeyValue<T, Name>
+  >,
+  IsArray extends boolean
+> = {
+  name: Name
+  validators?: Partial<Validators>
+
+  array?: IsArray
+  children: (
+    context: FormFieldContext<T, Name, Validators, IsArray>
+  ) => JSX.Element
+}
+
+export type FormFieldComponent<T extends Record<string, unknown>> = <
+  Name extends RecordKey<T>,
+  Validators extends FormFieldValidators<
+    RecordKey<T>,
+    InferRecordKeyValue<T, Name>
+  >,
+  IsArray extends boolean
+>(
+  props: FormFieldProps<T, Name, Validators, IsArray>
+) => JSX.Element
+
+export type SelectorState<T extends Record<string, unknown>> = {
+  values: T
+  canSubmit: boolean
+  isSubmitting: boolean
+}
+
+export type FormSubscribeProps<
+  T extends Record<string, unknown>,
+  SelectorFunction extends (state: SelectorState<T>) => unknown,
+  U
+> = {
+  selector: SelectorFunction
+  children: (selection: U) => JSX.Element
+}
+
+type FormSubscribeComponent<T extends Record<string, unknown>> = <
+  Selector extends (state: SelectorState<T>) => unknown
+>(
+  props: FormSubscribeProps<T, Selector, ReturnType<Selector>>
+) => JSX.Element
+
+export type UseFormState<T extends Record<string, unknown>> = {
+  Field: FormFieldComponent<T>
+  Subscribe: FormSubscribeComponent<T>
+  getFieldState: <K extends RecordKey<T>>(name: K) => FormFieldState<T, K>
+  handleSubmit: () => Promise<void>
+  reset: () => void
+}
+
+export type FormContext<T extends Record<string, unknown>> = {
+  state: T
+  validateForm: () => Promise<any[]>
+  resetField: (name: RecordKey<T>) => void
+  deleteField: (name: RecordKey<T>) => void
+  setFieldValue: <K extends RecordKey<T>>(
+    name: K,
+    value: InferRecordKeyValue<T, K>
+  ) => void
+}
+
+export type UseFormConfig<T extends Record<string, unknown>> = {
+  initialValues?: T
+  onSubmit?: (ctx: FormContext<T>) => void | Promise<void>
+  onSubmitInvalid?: (ctx: FormContext<T>) => void | Promise<void>
+}
+
+export interface FormStateSubscriber<T extends Record<string, unknown>> {
+  selector: (state: SelectorState<T>) => unknown
+  selection: ReturnType<this["selector"]>
+  update: () => void
+}
+
+export type UseFormInternalState<T extends Record<string, unknown>> = {
+  Field: FormFieldComponent<T>
+  Subscribe: FormSubscribeComponent<T>
+  formController: FormController<T>
+}
+
+export type FormController<T extends Record<string, unknown>> = {
+  subscribers: Set<FormStateSubscriber<T>>
+  state: T
+  validateField: (
+    name: RecordKey<T>,
+    type: "onChange" | "onSubmit" | "onMount" | "onBlur"
+  ) => Promise<void>
+  getFieldState: <K extends RecordKey<T>>(name: K) => FormFieldState<T, K>
+  setFieldValue: (
+    name: RecordKey<T>,
+    value: InferRecordKeyValue<T, RecordKey<T>>
+  ) => void
+  arrayFieldReplace: <K extends RecordKey<T>>(
+    name: K,
+    index: number,
+    value: InferRecordKeyValue<T, K> extends Array<infer U> ? U : any
+  ) => void
+  arrayFieldPush: <K extends RecordKey<T>>(
+    name: K,
+    value: InferRecordKeyValue<T, K> extends Array<infer U> ? U : any
+  ) => void
+  arrayFieldRemove: (name: RecordKey<T>, index: number) => void
+  connectField: (name: RecordKey<T>, update: () => void) => void
+  disconnectField: (name: RecordKey<T>, update: () => void) => void
+  setFieldValidators: <K extends RecordKey<T>>(
+    name: K,
+    validators: Partial<
+      FormFieldValidators<RecordKey<T>, InferRecordKeyValue<T, K>>
+    >
+  ) => void
+  getSelectorState: () => any
+  validateForm: () => Promise<string[]>
+  getFormContext: () => FormContext<T>
+  reset: (values?: T) => void
+}

package/src/form/utils.ts

@@ -0,0 +1,19 @@
+export const objSet = (
+  obj: Record<string, any>,
+  path: string[],
+  value: any
+) => {
+  let o = obj
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i]
+    if (i === path.length - 1) {
+      o[key] = value
+    } else {
+      o = o[key]
+    }
+  }
+}
+
+export const objGet = <T>(obj: Record<string, any>, path: string[]): T => {
+  return path.reduce((o, key) => o[key], obj) as T
+}

package/src/generateId.ts

@@ -0,0 +1,19 @@
+const DEFAULT_CHARACTERS =
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz-" as const
+
+/**
+ * Generates a random id
+ * @param {number} [size=10] size of the id (in number of characters)
+ * @param {string} [characterSet=defaultCharacterSet] set of characters to be used in the generation of the id
+ * @returns {string} random id of length {@link size}
+ */
+export function generateRandomID(
+  size: number = 10,
+  characterSet: string = DEFAULT_CHARACTERS
+): string {
+  let id = ""
+  for (let i = 0; i < size; i++) {
+    id += characterSet[(Math.random() * characterSet.length) | 0] // bitwise OR `|` is faster than `Math.floor()`
+  }
+  return id
+}

package/src/globalContext.ts

@@ -0,0 +1,161 @@
+import type { AppContext } from "./appContext"
+import { __DEV__ } from "./env.js"
+import { createHMRContext } from "./hmr.js"
+import { createProfilingContext } from "./profiling.js"
+import { Store } from "./store"
+
+export {
+  createKaiokenGlobalContext,
+  type GlobalKaiokenEvent,
+  type KaiokenGlobalContext,
+}
+
+interface ReactiveMap<V> {
+  add(key: string, value: V): void
+  delete(key: string): void
+  subscribe(cb: (value: Record<string, V>) => void): () => void
+  readonly size: number
+}
+
+function createReactiveMap<V>(): ReactiveMap<V> {
+  const map = new Map<string, V>()
+  const listeners = new Set<(value: Record<string, V>) => void>()
+
+  function add(key: string, value: V): void {
+    if (map.has(key)) return
+    map.set(key, value)
+    notify()
+  }
+
+  function deleteKey(key: string): void {
+    if (!map.has(key)) return
+    map.delete(key)
+    notify()
+  }
+
+  function notify(): void {
+    const val = Object.fromEntries(map)
+    listeners.forEach((cb) => cb(val))
+  }
+
+  function subscribe(cb: (value: Record<string, V>) => void): () => void {
+    listeners.add(cb)
+    cb(Object.fromEntries(map))
+    return () => listeners.delete(cb)
+  }
+
+  return {
+    add,
+    delete: deleteKey,
+    subscribe,
+    get size() {
+      return map.size
+    },
+  }
+}
+
+type Evt =
+  | {
+      name: "mount"
+      data?: undefined
+    }
+  | {
+      name: "unmount"
+      data?: undefined
+    }
+  | {
+      name: "update"
+      data?: undefined
+    }
+  | {
+      name: "error"
+      data: Error
+    }
+
+type GlobalKaiokenEvent = Evt["name"]
+
+interface KaiokenGlobalContext {
+  readonly apps: AppContext[]
+  stores?: ReactiveMap<Store<any, any>>
+  HMRContext?: ReturnType<typeof createHMRContext>
+  profilingContext?: ReturnType<typeof createProfilingContext>
+  globalState: Record<symbol, any>
+  emit<T extends Evt>(event: T["name"], ctx: AppContext, data?: T["data"]): void
+  on<T extends Evt>(
+    event: T["name"],
+    callback: (ctx: AppContext, data: T["data"]) => void
+  ): void
+  off<T extends Evt>(
+    event: T["name"],
+    callback: (ctx: AppContext, data?: T["data"]) => void
+  ): void
+}
+
+function createKaiokenGlobalContext(): KaiokenGlobalContext {
+  const contexts = new Set<AppContext>()
+  const listeners = new Map<
+    GlobalKaiokenEvent,
+    Set<(ctx: AppContext, data?: Evt["data"]) => void>
+  >()
+  const globalState: Record<symbol, any> = {}
+
+  let stores: ReactiveMap<Store<any, any>> | undefined
+  let HMRContext: ReturnType<typeof createHMRContext> | undefined
+  let profilingContext: ReturnType<typeof createProfilingContext> | undefined
+
+  function emit<T extends Evt>(
+    event: T["name"],
+    ctx: AppContext,
+    data?: T["data"]
+  ): void {
+    listeners.get(event)?.forEach((cb) => cb(ctx, data))
+  }
+
+  function on<T extends Evt>(
+    event: T["name"],
+    callback: (ctx: AppContext, data: T["data"]) => void
+  ): void {
+    if (!listeners.has(event)) {
+      listeners.set(event, new Set())
+    }
+    listeners.get(event)!.add(callback)
+  }
+
+  function off<T extends Evt>(
+    event: T["name"],
+    callback: (ctx: AppContext, data?: T["data"]) => void
+  ): void {
+    listeners.get(event)?.delete(callback)
+  }
+
+  const globalContext: KaiokenGlobalContext = {
+    get apps() {
+      return Array.from(contexts)
+    },
+    get stores() {
+      return stores
+    },
+    get HMRContext() {
+      return HMRContext
+    },
+    get profilingContext() {
+      return profilingContext
+    },
+    globalState,
+    emit,
+    on,
+    off,
+  }
+
+  // Initialize event listeners
+  on("mount", (ctx) => contexts.add(ctx))
+  on("unmount", (ctx) => contexts.delete(ctx))
+
+  if (__DEV__) {
+    HMRContext = createHMRContext()
+    profilingContext = createProfilingContext()
+    stores = createReactiveMap()
+  }
+
+  return globalContext
+}

package/src/globals.ts

@@ -0,0 +1,21 @@
+import type { AppContext } from "./appContext"
+
+export { node, hookIndex, ctx, renderMode, nodeToCtxMap }
+
+const node = {
+  current: null as Kaioken.VNode | null,
+}
+
+const hookIndex = {
+  current: 0,
+}
+
+const ctx = {
+  current: null! as AppContext<any>,
+}
+
+const renderMode = {
+  current: ("window" in globalThis ? "dom" : "string") as Kaioken.RenderMode,
+}
+
+const nodeToCtxMap = new WeakMap<Kaioken.VNode, AppContext<any>>()

package/src/hmr.ts

@@ -0,0 +1,178 @@
+import type { Store } from "./store"
+import type { WatchEffect } from "./signals/watch"
+import { $HMR_ACCEPT } from "./constants.js"
+import { __DEV__ } from "./env.js"
+import { Signal } from "./signals/base.js"
+import { traverseApply } from "./utils.js"
+import type { AppContext } from "./appContext"
+
+export type HMRAccept<T = {}> = {
+  provide: () => T
+  inject: (prev: T) => void
+  destroy: () => void
+}
+
+export type GenericHMRAcceptor<T = {}> = {
+  [$HMR_ACCEPT]: HMRAccept<T>
+}
+type HotVar = Kaioken.FC | Store<any, any> | Signal<any> | Kaioken.Context<any>
+
+type HotVarDesc = {
+  type: string
+  value: HotVar
+  hooks?: Array<{ name: string; args: string }>
+  link: string
+}
+
+export function isGenericHmrAcceptor(
+  thing: unknown
+): thing is GenericHMRAcceptor<any> {
+  return (
+    !!thing &&
+    (typeof thing === "object" || typeof thing === "function") &&
+    $HMR_ACCEPT in thing &&
+    typeof thing[$HMR_ACCEPT] === "object" &&
+    !!thing[$HMR_ACCEPT]
+  )
+}
+
+type ModuleMemory = {
+  hotVars: Map<string, HotVarDesc>
+  unnamedWatchers: Array<WatchEffect>
+}
+
+type HotVarRegistrationEntry = {
+  type: string
+  value: HotVar
+  link: string
+}
+
+export function createHMRContext() {
+  type FilePath = string
+  const moduleMap = new Map<FilePath, ModuleMemory>()
+  let currentModuleMemory: ModuleMemory | null = null
+  let isModuleReplacementExecution = false
+  const isReplacement = () => isModuleReplacementExecution
+  let isWaitingForNextWatchCall = false
+  let tmpUnnamedWatchers: WatchEffect[] = []
+
+  const onHmrCallbacks: Array<() => void> = []
+  const onHmr = (callback: () => void) => {
+    onHmrCallbacks.push(callback)
+  }
+
+  const prepare = (filePath: string) => {
+    let mod = moduleMap.get(filePath)
+    isModuleReplacementExecution = !!mod
+    if (!mod) {
+      mod = {
+        hotVars: new Map(),
+        unnamedWatchers: [],
+      }
+      moduleMap.set(filePath, mod)
+    } else {
+      while (onHmrCallbacks.length) onHmrCallbacks.shift()!()
+    }
+    currentModuleMemory = mod!
+  }
+
+  const register = (
+    hotVarRegistrationEntries: Record<string, HotVarRegistrationEntry>
+  ) => {
+    if (currentModuleMemory === null)
+      throw new Error("[kaioken]: HMR could not register: No active module")
+
+    let dirtiedApps: Set<AppContext> = new Set()
+    for (const [name, newEntry] of Object.entries(hotVarRegistrationEntries)) {
+      const oldEntry = currentModuleMemory.hotVars.get(name)
+
+      // @ts-ignore - this is how we tell devtools what file the hotvar is from
+      newEntry.value.__devtoolsFileLink = newEntry.link
+
+      if (typeof newEntry.value === "function") {
+        if (oldEntry?.value) {
+          /**
+           * this is how, when the previous function has been stored somewhere else (eg. in a Map, or by Vike),
+           * we can trace it to its latest version
+           */
+          // @ts-ignore
+          oldEntry.value.__next = newEntry.value
+        }
+      }
+
+      if (newEntry.type === "createStore") {
+        window.__kaioken!.stores!.add(name, newEntry.value as Store<any, any>)
+      }
+
+      currentModuleMemory.hotVars.set(name, newEntry)
+      if (!oldEntry) continue
+      if (
+        isGenericHmrAcceptor(oldEntry.value) &&
+        isGenericHmrAcceptor(newEntry.value)
+      ) {
+        newEntry.value[$HMR_ACCEPT].inject(
+          oldEntry.value[$HMR_ACCEPT].provide()
+        )
+        oldEntry.value[$HMR_ACCEPT].destroy()
+        continue
+      }
+      if (oldEntry.type === "component" && newEntry.type === "component") {
+        window.__kaioken!.apps.forEach((ctx) => {
+          if (!ctx.mounted || !ctx.rootNode) return
+          traverseApply(ctx.rootNode, (vNode) => {
+            if (vNode.type === oldEntry.value) {
+              vNode.type = newEntry.value as any
+              dirtiedApps.add(ctx)
+              vNode.hmrUpdated = true
+              if (vNode.prev) {
+                vNode.prev.type = newEntry.value as any
+              }
+            }
+          })
+        })
+      }
+    }
+    dirtiedApps.forEach((ctx) => ctx.requestUpdate())
+    isModuleReplacementExecution = false
+
+    if (tmpUnnamedWatchers.length) {
+      let i = 0
+      for (; i < tmpUnnamedWatchers.length; i++) {
+        const newWatcher = tmpUnnamedWatchers[i]
+        const oldWatcher = currentModuleMemory.unnamedWatchers[i]
+        if (oldWatcher) {
+          newWatcher[$HMR_ACCEPT]!.inject(oldWatcher[$HMR_ACCEPT]!.provide())
+          oldWatcher[$HMR_ACCEPT]!.destroy()
+        }
+        currentModuleMemory.unnamedWatchers[i] = newWatcher
+      }
+      for (; i < currentModuleMemory.unnamedWatchers.length; i++) {
+        const oldWatcher = currentModuleMemory.unnamedWatchers[i]
+        oldWatcher[$HMR_ACCEPT]!.destroy()
+      }
+      currentModuleMemory.unnamedWatchers.length = tmpUnnamedWatchers.length
+      tmpUnnamedWatchers.length = 0
+    }
+  }
+
+  const signals = {
+    registerNextWatch() {
+      isWaitingForNextWatchCall = true
+    },
+    isWaitingForNextWatchCall() {
+      return isWaitingForNextWatchCall
+    },
+    pushWatch(watch: WatchEffect) {
+      tmpUnnamedWatchers.push(watch)
+      isWaitingForNextWatchCall = false
+    },
+  }
+
+  return {
+    register,
+    prepare,
+    isReplacement,
+    signals,
+    onHmr,
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,14 @@
+export * from "./useAsync.js"
+export * from "./useCallback.js"
+export * from "./useContext.js"
+export * from "./useEffect.js"
+export * from "./useEffectEvent.js"
+export * from "./useId.js"
+export * from "./useLayoutEffect.js"
+export * from "./useMemo.js"
+export * from "./useReducer.js"
+export * from "./useRef.js"
+export * from "./useState.js"
+export * from "./useSyncExternalStore.js"
+export * from "./useViewTransition.js"
+export * from "./utils.js"