kiru 0.44.4

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2024-present, Rob (LankyMoose) Austen and Kaioken contributors
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# **Kaioken**
+
+#### A powerful, easy-to-use rendering library with a tiny footprint
+
+### <a href="https://kaioken.dev">kaioken.dev</a>

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "kiru",
+  "version": "0.44.4",
+  "description": "A batteries-included, easy-to-use rendering library with a tiny footprint",
+  "main": "dist/index.js",
+  "type": "module",
+  "homepage": "https://kiru.dev",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./form": {
+      "types": "./dist/form/index.d.ts",
+      "default": "./dist/form/index.js"
+    },
+    "./router": {
+      "types": "./dist/router/index.d.ts",
+      "default": "./dist/router/index.js"
+    },
+    "./swr": {
+      "types": "./dist/swr.d.ts",
+      "default": "./dist/swr.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "default": "./dist/utils.js"
+    },
+    "./ssr": {
+      "types": "./dist/ssr/index.d.ts",
+      "default": "./dist/ssr/index.js"
+    },
+    "./ssr/client": {
+      "types": "./dist/ssr/client.d.ts",
+      "default": "./dist/ssr/client.js"
+    },
+    "./ssr/server": {
+      "types": "./dist/ssr/server.d.ts",
+      "default": "./dist/ssr/server.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx.d.ts",
+      "default": "./dist/jsx.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx.d.ts",
+      "default": "./dist/jsx.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kirujs/kiru"
+  },
+  "types": "index.d.ts",
+  "keywords": [
+    "kiru",
+    "kirujs",
+    "kiru.js",
+    "dom",
+    "jsx",
+    "html",
+    "virtual-dom",
+    "reactive",
+    "signal"
+  ],
+  "author": "LankyMoose",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/chai": "^5.2.2",
+    "@types/jsdom": "^21.1.7",
+    "@types/mocha": "^10.0.10",
+    "chai": "^5.2.1",
+    "ts-mocha": "^10.1.0",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && pnpm i && tsc",
+    "test": "node --test",
+    "dev": "tsc --watch"
+  }
+}

package/src/appContext.ts

@@ -0,0 +1,186 @@
+import { flags } from "./flags.js"
+import { FLAG } from "./constants.js"
+import { createElement } from "./element.js"
+import { __DEV__ } from "./env.js"
+import { KaiokenError } from "./error.js"
+import { renderMode } from "./globals.js"
+import { hydrationStack } from "./hydration.js"
+import { createScheduler, Scheduler } from "./scheduler.js"
+import { generateRandomID } from "./generateId.js"
+
+type VNode = Kaioken.VNode
+
+export interface AppContextOptions {
+  root?: HTMLElement
+  /**
+   * @internal
+   * Sets the root node type for the app. Used for SSR & rendering without the DOM.
+   */
+  rootType?: ({ children }: { children: JSX.Children }) => JSX.Element
+  /**
+   * Sets the maximum render refresh time.
+   * @default 50
+   */
+  maxFrameMs?: number
+  name?: string
+  debug?: {
+    onRequestUpdate?: (vNode: VNode) => void
+  }
+}
+
+export interface AppContext<T extends Record<string, unknown> = {}> {
+  id: string
+  name: string
+  scheduler?: Scheduler
+  rootNode?: VNode
+  root?: HTMLElement
+  mounted: boolean
+  mount(): Promise<AppContext<T>>
+  unmount(): Promise<AppContext<T>>
+  setProps(fn: (oldProps: T) => T): Promise<AppContext<T>>
+  flushSync(): void
+  requestUpdate(vNode?: VNode): void
+  requestDelete(vNode: VNode): void
+}
+
+export function createAppContext<T extends Record<string, unknown> = {}>(
+  appFunc: (props: T) => JSX.Element,
+  appProps = {} as T,
+  options?: AppContextOptions
+): AppContext<T> {
+  const id = generateRandomID()
+  const name = options?.name ?? "App-" + id
+  let root = options?.root
+  let scheduler: Scheduler | undefined
+  let mounted = false
+  let appContext: AppContext<T>
+
+  const appNode = createElement(appFunc, appProps as T)
+  appNode.depth = 1
+  const rootNode = options?.rootType
+    ? createElement(options.rootType, {}, appNode)
+    : root
+    ? createElement(root!.nodeName.toLowerCase(), {}, appNode)
+    : void 0
+  if (rootNode) {
+    rootNode.depth = 0
+  }
+
+  function mount(): Promise<AppContext<T>> {
+    return new Promise<AppContext<T>>((resolve, reject) => {
+      if (mounted) return resolve(appContext)
+      if (!rootNode) return reject(new KaiokenError("Root node not configured"))
+      root ??= document.body
+      rootNode.dom = root
+      if (__DEV__) {
+        root.__kaiokenNode = rootNode
+      }
+      scheduler = createScheduler(appContext, options?.maxFrameMs ?? 50)
+      if (renderMode.current === "hydrate") {
+        hydrationStack.captureEvents(root!)
+      }
+      scheduler.nextIdle(() => {
+        if (renderMode.current === "hydrate") {
+          hydrationStack.releaseEvents(root!)
+        }
+        mounted = true
+        window.__kaioken?.emit("mount", appContext as AppContext<any>)
+        resolve(appContext)
+      }, false)
+      scheduler.queueUpdate(rootNode)
+      scheduler.flushSync()
+    })
+  }
+
+  function unmount(): Promise<AppContext<T>> {
+    return new Promise<AppContext<T>>((resolve) => {
+      if (!mounted) return resolve(appContext)
+      if (!rootNode?.child) return resolve(appContext)
+      requestDelete(rootNode.child)
+
+      scheduler?.nextIdle(() => {
+        scheduler = undefined
+        rootNode && (rootNode.child = null)
+        mounted = false
+        window.__kaioken?.emit("unmount", appContext as AppContext<any>)
+        resolve(appContext)
+      })
+    })
+  }
+
+  function setProps(fn: (oldProps: T) => T): Promise<AppContext<T>> {
+    const rootChild = rootNode?.child
+    if (!mounted || !rootChild || !scheduler)
+      throw new KaiokenError(
+        "Failed to apply new props - ensure the app is mounted"
+      )
+    return new Promise<AppContext<T>>((resolve) => {
+      scheduler!.clear()
+      const { children, ref, key, ...rest } = rootChild.props
+      rootChild.props = {
+        ...Object.assign(rest, fn(rest as T)),
+        children,
+        ref,
+        key,
+      }
+      scheduler!.queueUpdate(rootChild)
+      scheduler!.nextIdle(() => resolve(appContext))
+    })
+  }
+
+  function flushSync(): void {
+    scheduler?.flushSync()
+  }
+
+  function requestUpdate(vNode?: VNode): void {
+    if (!vNode) {
+      if (!mounted || !rootNode) return
+      vNode = rootNode
+    }
+    if (flags.get(vNode.flags, FLAG.DELETION)) return
+    if (__DEV__) {
+      if (options?.debug?.onRequestUpdate) {
+        options.debug.onRequestUpdate(vNode)
+      }
+    }
+    if (renderMode.current === "hydrate") {
+      return scheduler?.nextIdle((s) => {
+        !flags.get(vNode.flags, FLAG.DELETION) && s.queueUpdate(vNode)
+      })
+    }
+    scheduler?.queueUpdate(vNode)
+  }
+
+  function requestDelete(vNode: VNode): void {
+    if (flags.get(vNode.flags, FLAG.DELETION)) return
+    if (renderMode.current === "hydrate") {
+      return scheduler?.nextIdle((s) => {
+        !flags.get(vNode.flags, FLAG.DELETION) && s.queueDelete(vNode)
+      })
+    }
+    scheduler?.queueDelete(vNode)
+  }
+
+  return (appContext = {
+    id,
+    name,
+    get scheduler() {
+      return scheduler
+    },
+    get rootNode() {
+      return rootNode
+    },
+    get root() {
+      return root
+    },
+    get mounted() {
+      return mounted
+    },
+    mount,
+    unmount,
+    setProps,
+    flushSync,
+    requestUpdate,
+    requestDelete,
+  })
+}

package/src/cloneVNode.ts

@@ -0,0 +1,14 @@
+import { createElement } from "./element.js"
+import { isVNode } from "./utils.js"
+
+export function cloneVNode(vNode: Kaioken.VNode): Kaioken.VNode {
+  const children = vNode.props.children
+  let clonedChildren: unknown
+  if (isVNode(children)) {
+    clonedChildren = cloneVNode(children)
+  } else if (Array.isArray(children)) {
+    clonedChildren = children.map((c) => (isVNode(c) ? cloneVNode(c) : c))
+  }
+
+  return createElement(vNode.type, { ...vNode.props, children: clonedChildren })
+}

package/src/constants.ts

@@ -0,0 +1,146 @@
+export {
+  $SIGNAL,
+  $CONTEXT,
+  $CONTEXT_PROVIDER,
+  $FRAGMENT,
+  $KAIOKEN_ERROR,
+  $HMR_ACCEPT,
+  $MEMO,
+  $HYDRATION_BOUNDARY,
+  CONSECUTIVE_DIRTY_LIMIT,
+  FLAG,
+  REGEX_UNIT,
+}
+
+export { voidElements, svgTags, booleanAttributes }
+
+const $SIGNAL = Symbol.for("kaioken.signal")
+const $CONTEXT = Symbol.for("kaioken.context")
+const $CONTEXT_PROVIDER = Symbol.for("kaioken.contextProvider")
+const $FRAGMENT = Symbol.for("kaioken.fragment")
+const $KAIOKEN_ERROR = Symbol.for("kaioken.error")
+const $HMR_ACCEPT = Symbol.for("kaioken.hmrAccept")
+const $MEMO = Symbol.for("kaioken.memo")
+const $HYDRATION_BOUNDARY = Symbol.for("kaioken.hydrationBoundary")
+
+const CONSECUTIVE_DIRTY_LIMIT = 50
+
+const FLAG = {
+  UPDATE: 1,
+  PLACEMENT: 2,
+  DELETION: 3,
+  HAS_MEMO_ANCESTOR: 4,
+} as const
+
+const REGEX_UNIT = {
+  AMP_G: /&/g,
+  LT_G: /</g,
+  GT_G: />/g,
+  SQT_G: /'/g,
+  DBLQT_G: /"/g,
+  SLASH_G: /\//g,
+  SLASHN_SLASHR_G: /[\n\r]+/g,
+  ALPHA_UPPER_G: /[A-Z]/g,
+} as const
+
+const voidElements = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "source",
+  "track",
+  "wbr",
+])
+
+const svgTags = new Set([
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "feSpecularLighting",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "path",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "title",
+  "tspan",
+  "use",
+])
+
+const booleanAttributes = new Set([
+  "allowfullscreen",
+  "autofocus",
+  "autoplay",
+  "async",
+  "checked",
+  "compact",
+  "controls",
+  "contenteditable",
+  "declare",
+  "default",
+  "defer",
+  "disabled",
+  "download",
+  "hidden",
+  "inert",
+  "ismap",
+  "multiple",
+  "nohref",
+  "noresize",
+  "noshade",
+  "novalidate",
+  "nowrap",
+  "open",
+  "popover",
+  "readonly",
+  "required",
+  "sandbox",
+  "scoped",
+  "selected",
+  "sortable",
+  "spellcheck",
+  "translate",
+  "wrap",
+])

package/src/context.ts

@@ -0,0 +1,56 @@
+import { $CONTEXT, $CONTEXT_PROVIDER, $HMR_ACCEPT } from "./constants.js"
+import { createElement } from "./element.js"
+import { __DEV__ } from "./env.js"
+import { GenericHMRAcceptor } from "./hmr.js"
+import { useState } from "./hooks/useState.js"
+import { traverseApply } from "./utils.js"
+
+export function createContext<T>(defaultValue: T): Kaioken.Context<T> {
+  const ctx: Kaioken.Context<T> = {
+    [$CONTEXT]: true,
+    Provider: ({ value, children }: Kaioken.ProviderProps<T>) => {
+      const [dependents] = useState(() => new Set<Kaioken.VNode>())
+      return createElement(
+        $CONTEXT_PROVIDER,
+        { value, ctx, dependents },
+        typeof children === "function" ? children(value) : children
+      )
+    },
+    default: () => defaultValue,
+    set displayName(name: string) {
+      this.Provider.displayName = name
+    },
+    get displayName() {
+      return this.Provider.displayName || "Anonymous Context"
+    },
+  }
+  if (__DEV__) {
+    const asHmrAcceptor = ctx as any as GenericHMRAcceptor<Kaioken.Context<T>>
+    asHmrAcceptor[$HMR_ACCEPT] = {
+      inject: (prev) => {
+        const newProvider = ctx.Provider
+        window.__kaioken!.apps.forEach((ctx) => {
+          if (!ctx.mounted || !ctx.rootNode) return
+          traverseApply(ctx.rootNode, (vNode) => {
+            if (vNode.type === prev.Provider) {
+              vNode.type = newProvider
+              vNode.hmrUpdated = true
+              if (vNode.prev) {
+                vNode.prev.type = newProvider
+              }
+              ctx.requestUpdate(vNode)
+            }
+          })
+        })
+      },
+      destroy: () => {},
+      provide: () => ctx,
+    }
+  }
+
+  return ctx
+}
+
+export function isContext<T>(thing: unknown): thing is Kaioken.Context<T> {
+  return typeof thing === "object" && !!thing && $CONTEXT in thing
+}