kiru 0.44.4

package/src/element.ts

@@ -0,0 +1,54 @@
+import { $FRAGMENT, $MEMO } from "./constants.js"
+import { isMemoFn } from "./memo.js"
+import { isValidElementKeyProp, isValidElementRefProp } from "./props.js"
+
+export function createElement<T extends Kaioken.VNode["type"]>(
+  type: T,
+  props: null | Record<string, unknown> = null,
+  ...children: unknown[]
+): Kaioken.VNode {
+  if ((type as any) === Fragment) {
+    return Fragment({ children: children as any, ...props })
+  }
+  const node: Kaioken.VNode = {
+    type,
+    flags: 0,
+    index: 0,
+    depth: 0,
+    props: {},
+    parent: null,
+    sibling: null,
+    child: null,
+    prev: null,
+    deletions: null,
+  }
+  if (isMemoFn(type)) {
+    node.isMemoized = true
+    node.arePropsEqual = type[$MEMO].arePropsEqual
+  }
+
+  if (props !== null) {
+    const { key, ref, ...rest } = props
+    if (isValidElementKeyProp(key)) node.props.key = key.toString()
+    if (isValidElementRefProp(ref)) node.props.ref = ref
+    Object.assign(node.props, rest)
+  }
+
+  const _children =
+    children.length === 1 ? children[0] : children.length > 1 ? children : null
+  if (_children !== null) {
+    node.props.children = _children
+  }
+
+  return node
+}
+
+export function Fragment({
+  children,
+  key,
+}: {
+  children: JSX.Children
+  key?: JSX.ElementKey
+}): Kaioken.VNode {
+  return createElement($FRAGMENT, key ? { key } : null, children)
+}

package/src/env.ts

@@ -0,0 +1,6 @@
+const NODE_ENV = process.env.NODE_ENV
+if (NODE_ENV !== "development" && NODE_ENV !== "production") {
+  throw new Error("NODE_ENV must either be set to development or production.")
+}
+
+export const __DEV__ = NODE_ENV === "development"

package/src/error.ts

@@ -0,0 +1,85 @@
+import { $KAIOKEN_ERROR } from "./constants.js"
+import { __DEV__ } from "./env.js"
+import { findParent, noop } from "./utils.js"
+
+type KaiokenErrorOptions =
+  | string
+  | {
+      message: string
+      /** Used to indicate that the error is fatal and should crash the application */
+      fatal?: boolean
+      /** Used to generate custom node stack */
+      vNode?: Kaioken.VNode
+    }
+
+export class KaiokenError extends Error {
+  [$KAIOKEN_ERROR] = true
+  /** Indicates whether the error is fatal and should crash the application */
+  fatal?: boolean
+  /** Present if vNode is provided */
+  customNodeStack?: string
+  constructor(optionsOrMessage: KaiokenErrorOptions) {
+    const message =
+      typeof optionsOrMessage === "string"
+        ? optionsOrMessage
+        : optionsOrMessage.message
+    super(message)
+    if (typeof optionsOrMessage !== "string") {
+      if (__DEV__) {
+        if (optionsOrMessage?.vNode) {
+          this.customNodeStack = captureErrorStack(optionsOrMessage.vNode)
+        }
+      }
+      this.fatal = optionsOrMessage?.fatal
+    }
+  }
+
+  static isKaiokenError(error: unknown): error is KaiokenError {
+    return (
+      error instanceof Error && (error as KaiokenError)[$KAIOKEN_ERROR] === true
+    )
+  }
+}
+
+function captureErrorStack(vNode: Kaioken.VNode) {
+  let n = vNode
+  let componentFns: string[] = []
+  while (n) {
+    if (!n.parent) break // skip root node
+    if (typeof n.type === "function") {
+      componentFns.push(getComponentErrorDisplayText(n.type))
+    } else if (typeof n.type === "string") {
+      componentFns.push(n.type)
+    }
+    n = n.parent
+  }
+  const componentNode = (
+    typeof vNode.type === "function"
+      ? vNode
+      : findParent(vNode, (n) => typeof n.type === "function")
+  ) as (Kaioken.VNode & { type: Function }) | null
+  return `The above error occurred in the <${getFunctionName(
+    componentNode?.type || noop
+  )}> component:
+
+${componentFns.map((x) => `   at ${x}`).join("\n")}\n`
+}
+
+function getComponentErrorDisplayText(fn: Function) {
+  let str = getFunctionName(fn)
+  if (__DEV__) {
+    const fileLink = getComponentFileLink(fn)
+    if (fileLink) {
+      str = `${str} (${fileLink})`
+    }
+  }
+  return str
+}
+
+function getFunctionName(fn: Function) {
+  return (fn as any).displayName ?? (fn.name || "Anonymous Function")
+}
+
+function getComponentFileLink(fn: Function) {
+  return fn.toString().match(/\/\/ \[kaioken_devtools\]:(.*)/)?.[1] ?? null
+}

package/src/flags.ts

@@ -0,0 +1,15 @@
+export const flags = {
+  // Set the flag at position `n` (0-based index)
+  set(field: number, flag: number): number {
+    return (field |= 1 << flag)
+  },
+  // Check if the flag at position `n` is set (true) or not (false)
+  get(field: number, n: number): boolean {
+    return (field & (1 << n)) !== 0
+  },
+  // Unset all flags between `start` and `end`
+  unsetRange(field: number, start: number, end: number): number {
+    const mask = ((1 << (end - start + 1)) - 1) << start
+    return field & ~mask
+  },
+} as const