kiru 0.54.3 → 1.0.1

package/src/form/types.ts

@@ -1,262 +0,0 @@
-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
-  setSubmitting: (isSubmitting: boolean) => void
-}

package/src/form/utils.ts

@@ -1,19 +0,0 @@
-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/hooks/useAsync.ts

@@ -1,121 +0,0 @@
-import { __DEV__ } from "../env.js"
-import { noop, sideEffectsEnabled } from "../utils/index.js"
-import { depsRequireChange, useHook } from "./utils.js"
-import type { AsyncTaskState } from "../types.utils.js"
-
-export type UseAsyncState<T> = AsyncTaskState<T, UseAsyncError> & {
-  invalidate: () => void
-}
-
-export type UseAsyncCallbackContext = {
-  abortSignal: AbortSignal
-}
-
-export class UseAsyncError extends Error {
-  constructor(message: unknown) {
-    super(message instanceof Error ? message.message : String(message))
-    this.name = "UseAsyncError"
-    this.cause = message
-  }
-}
-
-type InternalTaskState<T> = {
-  data: T | null
-  loading: boolean
-  error: Error | null
-  abortController: AbortController
-}
-/**
- * Runs an asynchronous function on initial render, or when a value provided in the [dependency
- * array](https://kirujs.dev/docs/hooks/dependency-arrays) has changed.
- *
- * @see https://kirujs.dev/docs/hooks/useAsync
- */
-export function useAsync<T>(
-  func: (ctx: UseAsyncCallbackContext) => Promise<T>,
-  deps: unknown[]
-): UseAsyncState<T> {
-  if (!sideEffectsEnabled())
-    return {
-      data: null,
-      loading: true,
-      error: null,
-      invalidate: noop,
-    }
-  return useHook(
-    "useAsync",
-    {
-      deps,
-      id: 0,
-      task: null as any as InternalTaskState<T>,
-      load: noop as (
-        func: (ctx: UseAsyncCallbackContext) => Promise<T>
-      ) => void,
-    },
-    ({ hook, isInit, isHMR, update }) => {
-      if (__DEV__) {
-        hook.dev = { devtools: { get: () => ({ value: hook.task }) } }
-        if (isHMR) {
-          isInit = true
-        }
-      }
-      if (isInit) {
-        hook.cleanup = () => abortTask(hook.task)
-        hook.load = (func) => {
-          let invalidated = false
-          const abortController = new AbortController()
-          abortController.signal.addEventListener("abort", () => {
-            invalidated = true
-          })
-          const id = ++hook.id
-          const task: InternalTaskState<T> = (hook.task = {
-            abortController,
-            data: null,
-            loading: true,
-            error: null,
-          })
-          func({ abortSignal: abortController.signal })
-            .then((result: T) => {
-              if (id !== hook.id) abortTask(task)
-              if (invalidated) return
-
-              task.data = result
-              task.loading = false
-              task.error = null
-              update()
-            })
-            .catch((error) => {
-              if (id !== hook.id) abortTask(task)
-              if (invalidated) return
-
-              task.data = null
-              task.loading = false
-              task.error = new UseAsyncError(error)
-              update()
-            })
-        }
-      }
-
-      if (isInit || depsRequireChange(deps, hook.deps)) {
-        abortTask(hook.task)
-        hook.deps = deps
-        hook.load(func)
-      }
-
-      const { abortController, ...rest } = hook.task
-      return {
-        ...rest,
-        invalidate: () => {
-          abortTask(hook.task)
-          hook.load(func)
-          update()
-        },
-      } as UseAsyncState<T>
-    }
-  )
-}
-
-function abortTask<T>(task: InternalTaskState<T> | null): void {
-  if (task === null || task.abortController.signal.aborted) return
-  task.abortController.abort()
-}

package/src/hooks/useCallback.ts

@@ -1,32 +0,0 @@
-import { __DEV__ } from "../env.js"
-import { sideEffectsEnabled } from "../utils/index.js"
-import { depsRequireChange, useHook } from "./utils.js"
-
-/**
- * Creates a memoized callback function.
- *
- * @see https://kirujs.dev/docs/hooks/useCallback
- */
-export function useCallback<T extends Function>(
-  callback: T,
-  deps: unknown[]
-): T {
-  if (!sideEffectsEnabled()) return callback
-  return useHook("useCallback", { callback, deps }, ({ hook, isHMR }) => {
-    if (__DEV__) {
-      hook.dev = {
-        devtools: {
-          get: () => ({ callback: hook.callback, dependencies: hook.deps }),
-        },
-      }
-      if (isHMR) {
-        hook.deps = []
-      }
-    }
-    if (depsRequireChange(deps, hook.deps)) {
-      hook.deps = deps
-      hook.callback = callback
-    }
-    return hook.callback
-  })
-}

package/src/hooks/useContext.ts

@@ -1,79 +0,0 @@
-import type { ContextProviderNode } from "../types.utils.js"
-import { type HookCallbackState, useHook } from "./utils.js"
-import { __DEV__ } from "../env.js"
-import { $CONTEXT_PROVIDER } from "../constants.js"
-
-type UseContextHookState<T> = {
-  provider?: ContextProviderNode<T>
-  context: Kiru.Context<T>
-  warnIfNotFound: boolean
-}
-
-/**
- * Gets the current value of a context provider created by the context.
- *
- * @see https://kirujs.dev/docs/hooks/useContext
- */
-export function useContext<T>(
-  context: Kiru.Context<T>,
-  warnIfNotFound = true
-): T {
-  return useHook(
-    "useContext",
-    {
-      context,
-      warnIfNotFound,
-    } satisfies UseContextHookState<T>,
-    useContextCallback as typeof useContextCallback<T>
-  )
-}
-
-const useContextCallback = <T>({
-  hook,
-  isInit,
-  vNode,
-}: HookCallbackState<UseContextHookState<T>>) => {
-  if (__DEV__) {
-    hook.dev = {
-      devtools: {
-        get: () => ({
-          contextName: hook.context.Provider.displayName || "",
-          value: hook.provider
-            ? hook.provider.props.value
-            : hook.context.default(),
-        }),
-      },
-    }
-  }
-  if (isInit) {
-    let n = vNode.parent
-    while (n) {
-      if (n.type === $CONTEXT_PROVIDER) {
-        const provider = n as ContextProviderNode<T>
-        const { ctx, value, dependents } = provider.props
-        if (ctx === hook.context) {
-          dependents.add(vNode)
-          hook.cleanup = () => dependents.delete(vNode)
-          hook.provider = provider
-          return value
-        }
-      }
-      n = n.parent
-    }
-  }
-  if (!hook.provider) {
-    if (__DEV__) {
-      hook.warnIfNotFound && warnProviderNotFound(hook.context)
-    }
-    return hook.context.default()
-  }
-  return hook.provider.props.value
-}
-
-const contextsNotFound = new Set<Kiru.Context<any>>()
-function warnProviderNotFound(ctx: Kiru.Context<any>) {
-  if (!contextsNotFound.has(ctx)) {
-    contextsNotFound.add(ctx)
-    console.warn("[kiru]: Unable to find context provider")
-  }
-}

package/src/hooks/useEffect.ts

@@ -1,40 +0,0 @@
-import { sideEffectsEnabled } from "../utils/index.js"
-import { __DEV__ } from "../env.js"
-import { cleanupHook, depsRequireChange, useHook } from "./utils.js"
-
-/**
- * Runs a function after the component is rendered, or when a value provided in the optional [dependency
- * array](https://kirujs.dev/docs/hooks/dependency-arrays) has changed.
- *
- * @see https://kirujs.dev/docs/hooks/useEffect
- * */
-export function useEffect(
-  callback: () => void | (() => void),
-  deps?: unknown[]
-): void {
-  if (!sideEffectsEnabled()) return
-  return useHook(
-    "useEffect",
-    { deps },
-    ({ hook, isInit, isHMR, queueEffect }) => {
-      if (__DEV__) {
-        hook.dev = {
-          devtools: { get: () => ({ callback, dependencies: hook.deps }) },
-        }
-        if (isHMR) {
-          isInit = true
-        }
-      }
-      if (isInit || depsRequireChange(deps, hook.deps)) {
-        hook.deps = deps
-        cleanupHook(hook)
-        queueEffect(() => {
-          const cleanup = callback()
-          if (typeof cleanup === "function") {
-            hook.cleanup = cleanup
-          }
-        })
-      }
-    }
-  )
-}

package/src/hooks/useEffectEvent.ts

@@ -1,24 +0,0 @@
-import { sideEffectsEnabled } from "../utils/index.js"
-import { node } from "../globals.js"
-import { useHook } from "./utils.js"
-
-/**
- * Wraps a function to be called within effects and other callbacks.
- * The function will be called with the same arguments as the original function.
- *
- * @see https://kirujs.dev/docs/hooks/useEffectEvent
- */
-export function useEffectEvent<T extends Function>(callback: T): T {
-  if (!sideEffectsEnabled()) return callback
-  return useHook("useEffectEvent", { callback }, ({ hook }) => {
-    hook.callback = callback
-    return function () {
-      if (node.current) {
-        throw new Error(
-          "A function wrapped in useEffectEvent can't be called during rendering."
-        )
-      }
-      return hook.callback.apply(void 0, arguments)
-    } as any as T
-  })
-}

package/src/hooks/useId.ts

@@ -1,42 +0,0 @@
-import { __DEV__ } from "../env.js"
-import { HookCallback, useHook } from "./utils.js"
-
-/**
- * Creates a unique id for the current node. This is derived based on the node's position in your application tree.
- * Useful for assigning predictable ids to elements.
- *
- * @see https://kirujs.dev/docs/hooks/useId
- */
-export function useId(): string {
-  return useHook("useId", createUseIdState, useIdCallback)
-}
-
-type UseIdState = {
-  id: string
-  idx: number
-}
-
-const createUseIdState = (): UseIdState => ({
-  id: "",
-  idx: 0,
-})
-
-const useIdCallback: HookCallback<UseIdState> = ({ hook, isInit, vNode }) => {
-  if (__DEV__) {
-    hook.dev = {
-      devtools: { get: () => ({ id: hook.id }) },
-    }
-  }
-  if (isInit || vNode.index !== hook.idx) {
-    hook.idx = vNode.index
-    const accumulator: number[] = []
-    let n: Kiru.VNode | null = vNode
-    while (n) {
-      accumulator.push(n.index)
-      accumulator.push(n.depth)
-      n = n.parent
-    }
-    hook.id = `k:${BigInt(accumulator.join("")).toString(36)}`
-  }
-  return hook.id
-}

package/src/hooks/useLayoutEffect.ts

@@ -1,43 +0,0 @@
-import { sideEffectsEnabled } from "../utils/index.js"
-import { __DEV__ } from "../env.js"
-import { cleanupHook, depsRequireChange, useHook } from "./utils.js"
-
-/**
- * Runs a function before the component is rendered, or when a value provided in the optional [dependency
- * array](https://kirujs.dev/docs/hooks/dependency-arrays) has changed.
- *
- * @see https://kirujs.dev/docs/hooks/useLayoutEffect
- * */
-export function useLayoutEffect(
-  callback: () => void | (() => void),
-  deps?: unknown[]
-): void {
-  if (!sideEffectsEnabled()) return
-  return useHook(
-    "useLayoutEffect",
-    { deps },
-    ({ hook, isInit, isHMR, queueEffect }) => {
-      if (__DEV__) {
-        hook.dev = {
-          devtools: { get: () => ({ callback, dependencies: hook.deps }) },
-        }
-        if (isHMR) {
-          isInit = true
-        }
-      }
-      if (isInit || depsRequireChange(deps, hook.deps)) {
-        hook.deps = deps
-        cleanupHook(hook)
-        queueEffect(
-          () => {
-            const cleanup = callback()
-            if (typeof cleanup === "function") {
-              hook.cleanup = cleanup
-            }
-          },
-          { immediate: true }
-        )
-      }
-    }
-  )
-}

package/src/hooks/useMemo.ts

@@ -1,34 +0,0 @@
-import { sideEffectsEnabled } from "../utils/index.js"
-import { __DEV__ } from "../env.js"
-import { depsRequireChange, useHook } from "./utils.js"
-
-/**
- * Creates a memoized value that only changes when the [dependency
- * array](https://kirujs.dev/docs/hooks/dependency-arrays) has changed.
- *
- * @see https://kirujs.dev/docs/hooks/useMemo
- */
-export function useMemo<T>(factory: () => T, deps: unknown[]): T {
-  if (!sideEffectsEnabled()) return factory()
-  return useHook(
-    "useMemo",
-    { deps, value: undefined as T },
-    ({ hook, isInit, isHMR }) => {
-      if (__DEV__) {
-        hook.dev = {
-          devtools: {
-            get: () => ({ value: hook.value, dependencies: hook.deps }),
-          },
-        }
-        if (isHMR) {
-          isInit = true
-        }
-      }
-      if (isInit || depsRequireChange(deps, hook.deps)) {
-        hook.deps = deps
-        hook.value = factory()
-      }
-      return hook.value
-    }
-  )
-}