bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,89 +0,0 @@
-/**
- * @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

@@ -1,39 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,246 +0,0 @@
-/**
- * @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

@@ -1,91 +0,0 @@
-/**
- * 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

@@ -1,159 +0,0 @@
-/**
- * @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'