bluera-knowledge 0.9.21

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/client.ts

@@ -0,0 +1,89 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom/client`, which is compatible with `react-dom/client`.
+ */
+
+import type { Child } from '../base'
+import { useState } from '../hooks'
+import { buildNode, renderNode } from './render'
+import type { NodeObject } from './render'
+
+export interface Root {
+  render(children: Child): void
+  unmount(): void
+}
+export type RootOptions = Record<string, unknown>
+
+/**
+ * Create a root object for rendering
+ * @param element Render target
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export const createRoot = (
+  element: HTMLElement | DocumentFragment,
+  options: RootOptions = {}
+): Root => {
+  let setJsxNode:
+    | undefined // initial state
+    | ((jsxNode: unknown) => void) // rendered
+    | null = // unmounted
+    undefined
+
+  if (Object.keys(options).length > 0) {
+    console.warn('createRoot options are not supported yet')
+  }
+
+  return {
+    render(jsxNode: unknown) {
+      if (setJsxNode === null) {
+        // unmounted
+        throw new Error('Cannot update an unmounted root')
+      }
+      if (setJsxNode) {
+        // rendered
+        setJsxNode(jsxNode)
+      } else {
+        renderNode(
+          buildNode({
+            tag: () => {
+              const [_jsxNode, _setJsxNode] = useState(jsxNode)
+              setJsxNode = _setJsxNode
+              return _jsxNode
+            },
+            props: {},
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          } as any) as NodeObject,
+          element
+        )
+      }
+    },
+    unmount() {
+      setJsxNode?.(null)
+      setJsxNode = null
+    },
+  }
+}
+
+/**
+ * Create a root object and hydrate app to the target element.
+ * In hono/jsx/dom, hydrate is equivalent to render.
+ * @param element Render target
+ * @param reactNode A JSXNode to render
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export const hydrateRoot = (
+  element: HTMLElement | DocumentFragment,
+  reactNode: Child,
+  options: RootOptions = {}
+): Root => {
+  const root = createRoot(element, options)
+  root.render(reactNode)
+  return root
+}
+
+export default {
+  createRoot,
+  hydrateRoot,
+}

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/components.ts

@@ -0,0 +1,39 @@
+import type { Child, FC, PropsWithChildren } from '../'
+import type { ErrorHandler, FallbackRender } from '../components'
+import { DOM_ERROR_HANDLER } from '../constants'
+import { Fragment } from './jsx-runtime'
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const ErrorBoundary: FC<
+  PropsWithChildren<{
+    fallback?: Child
+    fallbackRender?: FallbackRender
+    onError?: ErrorHandler
+  }>
+> = (({ children, fallback, fallbackRender, onError }: any) => {
+  const res = Fragment({ children })
+  ;(res as any)[DOM_ERROR_HANDLER] = (err: any) => {
+    if (err instanceof Promise) {
+      throw err
+    }
+    onError?.(err)
+    return fallbackRender?.(err) || fallback
+  }
+  return res
+}) as any
+
+export const Suspense: FC<PropsWithChildren<{ fallback: any }>> = (({
+  children,
+  fallback,
+}: any) => {
+  const res = Fragment({ children })
+  ;(res as any)[DOM_ERROR_HANDLER] = (err: any, retry: () => void) => {
+    if (!(err instanceof Promise)) {
+      throw err
+    }
+    err.finally(retry)
+    return fallback
+  }
+  return res
+}) as any
+/* eslint-enable @typescript-eslint/no-explicit-any */

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/context.ts

@@ -0,0 +1,52 @@
+import type { Child } from '../base'
+import { DOM_ERROR_HANDLER } from '../constants'
+import type { Context } from '../context'
+import { globalContexts } from '../context'
+import { setInternalTagFlag } from './utils'
+
+export const createContextProviderFunction =
+  <T>(values: T[]): Function =>
+  ({ value, children }: { value: T; children: Child[] }) => {
+    if (!children) {
+      return undefined
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const props: { children: any } = {
+      children: [
+        {
+          tag: setInternalTagFlag(() => {
+            values.push(value)
+          }),
+          props: {},
+        },
+      ],
+    }
+    if (Array.isArray(children)) {
+      props.children.push(...children.flat())
+    } else {
+      props.children.push(children)
+    }
+    props.children.push({
+      tag: setInternalTagFlag(() => {
+        values.pop()
+      }),
+      props: {},
+    })
+    const res = { tag: '', props, type: '' }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ;(res as any)[DOM_ERROR_HANDLER] = (err: unknown) => {
+      values.pop()
+      throw err
+    }
+    return res
+  }
+
+export const createContext = <T>(defaultValue: T): Context<T> => {
+  const values = [defaultValue]
+  const context: Context<T> = createContextProviderFunction(values) as Context<T>
+  context.values = values
+  context.Provider = context
+  globalContexts.push(context as Context<unknown>)
+  return context
+}

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/css.ts

@@ -0,0 +1,246 @@
+/**
+ * @module
+ * This module provides APIs that enable `hono/jsx/dom` to support.
+ */
+
+import type { FC, PropsWithChildren } from '../'
+import type { CssClassName, CssVariableType } from '../../helper/css/common'
+import {
+  CLASS_NAME,
+  DEFAULT_STYLE_ID,
+  PSEUDO_GLOBAL_SELECTOR,
+  SELECTOR,
+  SELECTORS,
+  STYLE_STRING,
+  cssCommon,
+  cxCommon,
+  keyframesCommon,
+  viewTransitionCommon,
+} from '../../helper/css/common'
+export { rawCssString } from '../../helper/css/common'
+
+const splitRule = (rule: string): string[] => {
+  const result: string[] = []
+  let startPos = 0
+  let depth = 0
+  for (let i = 0, len = rule.length; i < len; i++) {
+    const char = rule[i]
+
+    // consume quote
+    // eslint-disable-next-line quotes
+    if (char === "'" || char === '"') {
+      const quote = char
+      i++
+      for (; i < len; i++) {
+        if (rule[i] === '\\') {
+          i++
+          continue
+        }
+        if (rule[i] === quote) {
+          break
+        }
+      }
+      continue
+    }
+
+    // comments are removed from the rule in advance
+
+    if (char === '{') {
+      depth++
+      continue
+    }
+    if (char === '}') {
+      depth--
+      if (depth === 0) {
+        result.push(rule.slice(startPos, i + 1))
+        startPos = i + 1
+      }
+      continue
+    }
+  }
+  return result
+}
+
+interface CreateCssJsxDomObjectsType {
+  (args: { id: Readonly<string> }): readonly [
+    {
+      toString(this: CssClassName): string
+    },
+    FC<PropsWithChildren<void>>
+  ]
+}
+
+export const createCssJsxDomObjects: CreateCssJsxDomObjectsType = ({ id }) => {
+  let styleSheet: CSSStyleSheet | null | undefined = undefined
+  const findStyleSheet = (): [CSSStyleSheet, Set<string>] | [] => {
+    if (!styleSheet) {
+      styleSheet = document.querySelector<HTMLStyleElement>(`style#${id}`)
+        ?.sheet as CSSStyleSheet | null
+      if (styleSheet) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ;(styleSheet as any).addedStyles = new Set<string>()
+      }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return styleSheet ? [styleSheet, (styleSheet as any).addedStyles] : []
+  }
+
+  const insertRule = (className: string, styleString: string) => {
+    const [sheet, addedStyles] = findStyleSheet()
+    if (!sheet || !addedStyles) {
+      Promise.resolve().then(() => {
+        if (!findStyleSheet()[0]) {
+          throw new Error('style sheet not found')
+        }
+        insertRule(className, styleString)
+      })
+      return
+    }
+
+    if (!addedStyles.has(className)) {
+      addedStyles.add(className)
+      ;(className.startsWith(PSEUDO_GLOBAL_SELECTOR)
+        ? splitRule(styleString)
+        : [`${className[0] === '@' ? '' : '.'}${className}{${styleString}}`]
+      ).forEach((rule) => {
+        sheet.insertRule(rule, sheet.cssRules.length)
+      })
+    }
+  }
+
+  const cssObject = {
+    toString(this: CssClassName): string {
+      const selector = this[SELECTOR]
+      insertRule(selector, this[STYLE_STRING])
+      this[SELECTORS].forEach(({ [CLASS_NAME]: className, [STYLE_STRING]: styleString }) => {
+        insertRule(className, styleString)
+      })
+
+      return this[CLASS_NAME]
+    },
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const Style: FC<PropsWithChildren<void>> = ({ children }) =>
+    ({
+      tag: 'style',
+      props: {
+        id,
+        children:
+          children &&
+          (Array.isArray(children) ? children : [children]).map(
+            (c) => (c as unknown as CssClassName)[STYLE_STRING]
+          ),
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any)
+
+  return [cssObject, Style] as const
+}
+
+interface CssType {
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): string
+}
+
+interface CxType {
+  (...args: (string | boolean | null | undefined)[]): string
+}
+
+interface KeyframesType {
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName
+}
+
+interface ViewTransitionType {
+  (strings: TemplateStringsArray, ...values: CssVariableType[]): string
+  (content: string): string
+  (): string
+}
+
+interface DefaultContextType {
+  css: CssType
+  cx: CxType
+  keyframes: KeyframesType
+  viewTransition: ViewTransitionType
+  Style: FC<PropsWithChildren<void>>
+}
+
+/**
+ * @experimental
+ * `createCssContext` is an experimental feature.
+ * The API might be changed.
+ */
+export const createCssContext = ({ id }: { id: Readonly<string> }): DefaultContextType => {
+  const [cssObject, Style] = createCssJsxDomObjects({ id })
+
+  const newCssClassNameObject = (cssClassName: CssClassName): string => {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    cssClassName.toString = cssObject.toString
+    return cssClassName as unknown as string
+  }
+
+  const css: CssType = (strings, ...values) => {
+    return newCssClassNameObject(cssCommon(strings, values))
+  }
+
+  const cx: CxType = (...args) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    args = cxCommon(args as any) as any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return css(Array(args.length).fill('') as any, ...args)
+  }
+
+  const keyframes: KeyframesType = keyframesCommon
+
+  const viewTransition: ViewTransitionType = ((
+    strings: TemplateStringsArray | string | undefined,
+    ...values: CssVariableType[]
+  ) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return newCssClassNameObject(viewTransitionCommon(strings as any, values))
+  }) as ViewTransitionType
+
+  return {
+    css,
+    cx,
+    keyframes,
+    viewTransition,
+    Style,
+  }
+}
+
+const defaultContext: DefaultContextType = createCssContext({ id: DEFAULT_STYLE_ID })
+
+/**
+ * @experimental
+ * `css` is an experimental feature.
+ * The API might be changed.
+ */
+export const css = defaultContext.css
+
+/**
+ * @experimental
+ * `cx` is an experimental feature.
+ * The API might be changed.
+ */
+export const cx = defaultContext.cx
+
+/**
+ * @experimental
+ * `keyframes` is an experimental feature.
+ * The API might be changed.
+ */
+export const keyframes = defaultContext.keyframes
+
+/**
+ * @experimental
+ * `viewTransition` is an experimental feature.
+ * The API might be changed.
+ */
+export const viewTransition = defaultContext.viewTransition
+
+/**
+ * @experimental
+ * `Style` is an experimental feature.
+ * The API might be changed.
+ */
+export const Style = defaultContext.Style

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/hooks/index.ts

@@ -0,0 +1,91 @@
+/**
+ * Provide hooks used only in jsx/dom
+ */
+
+import type { Context } from '../../context'
+import { useContext } from '../../context'
+import { createContext } from '../context'
+import { useCallback, useState } from '../../hooks'
+import { PERMALINK } from '../../constants'
+
+type FormStatus =
+  | {
+      pending: false
+      data: null
+      method: null
+      action: null
+    }
+  | {
+      pending: true
+      data: FormData
+      method: 'get' | 'post'
+      action: string | ((formData: FormData) => void | Promise<void>)
+    }
+export const FormContext: Context<FormStatus> = createContext<FormStatus>({
+  pending: false,
+  data: null,
+  method: null,
+  action: null,
+})
+
+const actions: Set<Promise<unknown>> = new Set()
+export const registerAction = (action: Promise<unknown>) => {
+  actions.add(action)
+  action.finally(() => actions.delete(action))
+}
+
+/**
+ * This hook returns the current form status
+ * @returns FormStatus
+ */
+export const useFormStatus = (): FormStatus => {
+  return useContext(FormContext)
+}
+
+/**
+ * This hook returns the current state and a function to update the state optimistically
+ * The current state is updated optimistically and then reverted to the original state when all actions are resolved
+ * @param state
+ * @param updateState
+ * @returns [T, (action: N) => void]
+ */
+export const useOptimistic = <T, N>(
+  state: T,
+  updateState: (currentState: T, action: N) => T
+): [T, (action: N) => void] => {
+  const [optimisticState, setOptimisticState] = useState(state)
+  if (actions.size > 0) {
+    Promise.all(actions).finally(() => {
+      setOptimisticState(state)
+    })
+  } else {
+    setOptimisticState(state)
+  }
+
+  const cb = useCallback((newData: N) => {
+    setOptimisticState((currentState) => updateState(currentState, newData))
+  }, [])
+
+  return [optimisticState, cb]
+}
+
+/**
+ * This hook returns the current state and a function to update the state by form action
+ * @param fn
+ * @param initialState
+ * @param permalink
+ * @returns [T, (data: FormData) => void]
+ */
+export const useActionState = <T>(
+  fn: Function,
+  initialState: T,
+  permalink?: string
+): [T, Function] => {
+  const [state, setState] = useState(initialState)
+  const actionState = async (data: FormData) => {
+    setState(await fn(state, data))
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ;(actionState as any)[PERMALINK] = permalink
+  return [state, actionState]
+}

package/tests/fixtures/corpus/oss-repos/hono/src/jsx/dom/index.ts

@@ -0,0 +1,159 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom`.
+ */
+
+import { isValidElement, memo, reactAPICompatVersion } from '../base'
+import type { Child, DOMAttributes, JSX, JSXNode, Props } from '../base'
+import { Children } from '../children'
+import { useContext } from '../context'
+import {
+  createRef,
+  forwardRef,
+  startTransition,
+  startViewTransition,
+  use,
+  useCallback,
+  useDebugValue,
+  useDeferredValue,
+  useEffect,
+  useId,
+  useImperativeHandle,
+  useInsertionEffect,
+  useLayoutEffect,
+  useMemo,
+  useReducer,
+  useRef,
+  useState,
+  useSyncExternalStore,
+  useTransition,
+  useViewTransition,
+} from '../hooks'
+import { useActionState, useFormStatus, useOptimistic } from './hooks'
+import { ErrorBoundary, Suspense } from './components'
+import { createContext } from './context'
+import { Fragment, jsx } from './jsx-runtime'
+import { createPortal, flushSync } from './render'
+
+export { render } from './render'
+
+const createElement = (
+  tag: string | ((props: Props) => JSXNode),
+  props: Props | null,
+  ...children: Child[]
+): JSXNode => {
+  const jsxProps: Props = props ? { ...props } : {}
+  if (children.length) {
+    jsxProps.children = children.length === 1 ? children[0] : children
+  }
+
+  let key = undefined
+  if ('key' in jsxProps) {
+    key = jsxProps.key
+    delete jsxProps.key
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return jsx(tag, jsxProps, key) as any
+}
+
+const cloneElement = <T extends JSXNode | JSX.Element>(
+  element: T,
+  props: Props,
+  ...children: Child[]
+): T => {
+  return jsx(
+    (element as JSXNode).tag,
+    {
+      ...(element as JSXNode).props,
+      ...props,
+      children: children.length ? children : (element as JSXNode).props.children,
+    },
+    (element as JSXNode).key
+  ) as T
+}
+
+export {
+  reactAPICompatVersion as version,
+  createElement as jsx,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  useInsertionEffect,
+  useReducer,
+  useId,
+  useDebugValue,
+  createRef,
+  forwardRef,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useFormStatus,
+  useActionState,
+  useOptimistic,
+  Suspense,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  memo,
+  isValidElement,
+  createElement,
+  cloneElement,
+  Children,
+  Fragment,
+  Fragment as StrictMode,
+  DOMAttributes,
+  flushSync,
+  createPortal,
+}
+
+export default {
+  version: reactAPICompatVersion,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+  use,
+  startTransition,
+  useTransition,
+  useDeferredValue,
+  startViewTransition,
+  useViewTransition,
+  useMemo,
+  useLayoutEffect,
+  useInsertionEffect,
+  useReducer,
+  useId,
+  useDebugValue,
+  createRef,
+  forwardRef,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useFormStatus,
+  useActionState,
+  useOptimistic,
+  Suspense,
+  ErrorBoundary,
+  createContext,
+  useContext,
+  memo,
+  isValidElement,
+  createElement,
+  cloneElement,
+  Children,
+  Fragment,
+  StrictMode: Fragment,
+  flushSync,
+  createPortal,
+}
+
+export type { Context } from '../context'
+
+export type * from '../types'