bluera-knowledge 0.14.0 → 0.14.2

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

@@ -1,419 +0,0 @@
-import { raw } from '../helper/html'
-import { escapeToBuffer, resolveCallbackSync, stringBufferToString } from '../utils/html'
-import type { HtmlEscaped, HtmlEscapedString, StringBufferWithCallbacks } from '../utils/html'
-import type { Context } from './context'
-import { createContext, globalContexts, useContext } from './context'
-import { DOM_RENDERER } from './constants'
-import type {
-  JSX as HonoJSX,
-  IntrinsicElements as IntrinsicElementsDefined,
-} from './intrinsic-elements'
-import { normalizeIntrinsicElementKey, styleObjectForEach } from './utils'
-import * as intrinsicElementTags from './intrinsic-element/components'
-import { domRenderers } from './intrinsic-element/common'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Props = Record<string, any>
-export type FC<P = Props> = {
-  (props: P): HtmlEscapedString | Promise<HtmlEscapedString> | null
-  defaultProps?: Partial<P> | undefined
-  displayName?: string | undefined
-}
-export type DOMAttributes = HonoJSX.HTMLAttributes
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace JSX {
-  export type Element = HtmlEscapedString | Promise<HtmlEscapedString>
-  export interface ElementChildrenAttribute {
-    children: Child
-  }
-  export interface IntrinsicElements extends IntrinsicElementsDefined {
-    [tagName: string]: Props
-  }
-}
-
-let nameSpaceContext: Context<string> | undefined = undefined
-export const getNameSpaceContext = () => nameSpaceContext
-
-const toSVGAttributeName = (key: string): string =>
-  /[A-Z]/.test(key) &&
-  // Presentation attributes are findable in style object. "clip-path", "font-size", "stroke-width", etc.
-  // Or other un-deprecated kebab-case attributes. "overline-position", "paint-order", "strikethrough-position", etc.
-  key.match(
-    /^(?:al|basel|clip(?:Path|Rule)$|co|do|fill|fl|fo|gl|let|lig|i|marker[EMS]|o|pai|pointe|sh|st[or]|text[^L]|tr|u|ve|w)/
-  )
-    ? key.replace(/([A-Z])/g, '-$1').toLowerCase()
-    : key
-
-const emptyTags = [
-  'area',
-  'base',
-  'br',
-  'col',
-  'embed',
-  'hr',
-  'img',
-  'input',
-  'keygen',
-  'link',
-  'meta',
-  'param',
-  'source',
-  'track',
-  'wbr',
-]
-const booleanAttributes = [
-  'allowfullscreen',
-  'async',
-  'autofocus',
-  'autoplay',
-  'checked',
-  'controls',
-  'default',
-  'defer',
-  'disabled',
-  'download',
-  'formnovalidate',
-  'hidden',
-  'inert',
-  'ismap',
-  'itemscope',
-  'loop',
-  'multiple',
-  'muted',
-  'nomodule',
-  'novalidate',
-  'open',
-  'playsinline',
-  'readonly',
-  'required',
-  'reversed',
-  'selected',
-]
-
-const childrenToStringToBuffer = (children: Child[], buffer: StringBufferWithCallbacks): void => {
-  for (let i = 0, len = children.length; i < len; i++) {
-    const child = children[i]
-    if (typeof child === 'string') {
-      escapeToBuffer(child, buffer)
-    } else if (typeof child === 'boolean' || child === null || child === undefined) {
-      continue
-    } else if (child instanceof JSXNode) {
-      child.toStringToBuffer(buffer)
-    } else if (
-      typeof child === 'number' ||
-      (child as unknown as { isEscaped: boolean }).isEscaped
-    ) {
-      ;(buffer[0] as string) += child
-    } else if (child instanceof Promise) {
-      buffer.unshift('', child)
-    } else {
-      // `child` type is `Child[]`, so stringify recursively
-      childrenToStringToBuffer(child, buffer)
-    }
-  }
-}
-
-type LocalContexts = [Context<unknown>, unknown][]
-export type Child =
-  | string
-  | Promise<string>
-  | number
-  | JSXNode
-  | null
-  | undefined
-  | boolean
-  | Child[]
-export class JSXNode implements HtmlEscaped {
-  tag: string | Function
-  props: Props
-  key?: string
-  children: Child[]
-  isEscaped: true = true as const
-  localContexts?: LocalContexts
-  constructor(tag: string | Function, props: Props, children: Child[]) {
-    this.tag = tag
-    this.props = props
-    this.children = children
-  }
-
-  get type(): string | Function {
-    return this.tag as string
-  }
-
-  // Added for compatibility with libraries that rely on React's internal structure
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  get ref(): any {
-    return this.props.ref || null
-  }
-
-  toString(): string | Promise<string> {
-    const buffer: StringBufferWithCallbacks = [''] as StringBufferWithCallbacks
-    this.localContexts?.forEach(([context, value]) => {
-      context.values.push(value)
-    })
-    try {
-      this.toStringToBuffer(buffer)
-    } finally {
-      this.localContexts?.forEach(([context]) => {
-        context.values.pop()
-      })
-    }
-    return buffer.length === 1
-      ? 'callbacks' in buffer
-        ? resolveCallbackSync(raw(buffer[0], buffer.callbacks)).toString()
-        : buffer[0]
-      : stringBufferToString(buffer, buffer.callbacks)
-  }
-
-  toStringToBuffer(buffer: StringBufferWithCallbacks): void {
-    const tag = this.tag as string
-    const props = this.props
-    let { children } = this
-
-    buffer[0] += `<${tag}`
-
-    const normalizeKey: (key: string) => string =
-      nameSpaceContext && useContext(nameSpaceContext) === 'svg'
-        ? (key) => toSVGAttributeName(normalizeIntrinsicElementKey(key))
-        : (key) => normalizeIntrinsicElementKey(key)
-    for (let [key, v] of Object.entries(props)) {
-      key = normalizeKey(key)
-      if (key === 'children') {
-        // skip children
-      } else if (key === 'style' && typeof v === 'object') {
-        // object to style strings
-        let styleStr = ''
-        styleObjectForEach(v, (property, value) => {
-          if (value != null) {
-            styleStr += `${styleStr ? ';' : ''}${property}:${value}`
-          }
-        })
-        buffer[0] += ' style="'
-        escapeToBuffer(styleStr, buffer)
-        buffer[0] += '"'
-      } else if (typeof v === 'string') {
-        buffer[0] += ` ${key}="`
-        escapeToBuffer(v, buffer)
-        buffer[0] += '"'
-      } else if (v === null || v === undefined) {
-        // Do nothing
-      } else if (typeof v === 'number' || (v as HtmlEscaped).isEscaped) {
-        buffer[0] += ` ${key}="${v}"`
-      } else if (typeof v === 'boolean' && booleanAttributes.includes(key)) {
-        if (v) {
-          buffer[0] += ` ${key}=""`
-        }
-      } else if (key === 'dangerouslySetInnerHTML') {
-        if (children.length > 0) {
-          throw 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.'
-        }
-
-        children = [raw(v.__html)]
-      } else if (v instanceof Promise) {
-        buffer[0] += ` ${key}="`
-        buffer.unshift('"', v)
-      } else if (typeof v === 'function') {
-        if (!key.startsWith('on')) {
-          throw `Invalid prop '${key}' of type 'function' supplied to '${tag}'.`
-        }
-        // maybe event handler for client components, just ignore in server components
-      } else {
-        buffer[0] += ` ${key}="`
-        escapeToBuffer(v.toString(), buffer)
-        buffer[0] += '"'
-      }
-    }
-
-    if (emptyTags.includes(tag as string) && children.length === 0) {
-      buffer[0] += '/>'
-      return
-    }
-
-    buffer[0] += '>'
-
-    childrenToStringToBuffer(children, buffer)
-
-    buffer[0] += `</${tag}>`
-  }
-}
-
-class JSXFunctionNode extends JSXNode {
-  toStringToBuffer(buffer: StringBufferWithCallbacks): void {
-    const { children } = this
-
-    const res = (this.tag as Function).call(null, {
-      ...this.props,
-      children: children.length <= 1 ? children[0] : children,
-    })
-
-    if (typeof res === 'boolean' || res == null) {
-      // boolean or null or undefined
-      return
-    } else if (res instanceof Promise) {
-      if (globalContexts.length === 0) {
-        buffer.unshift('', res)
-      } else {
-        // save current contexts for resuming
-        const currentContexts: LocalContexts = globalContexts.map((c) => [c, c.values.at(-1)])
-        buffer.unshift(
-          '',
-          res.then((childRes) => {
-            if (childRes instanceof JSXNode) {
-              childRes.localContexts = currentContexts
-            }
-            return childRes
-          })
-        )
-      }
-    } else if (res instanceof JSXNode) {
-      res.toStringToBuffer(buffer)
-    } else if (typeof res === 'number' || (res as HtmlEscaped).isEscaped) {
-      buffer[0] += res
-      if (res.callbacks) {
-        buffer.callbacks ||= []
-        buffer.callbacks.push(...res.callbacks)
-      }
-    } else {
-      escapeToBuffer(res, buffer)
-    }
-  }
-}
-
-export class JSXFragmentNode extends JSXNode {
-  toStringToBuffer(buffer: StringBufferWithCallbacks): void {
-    childrenToStringToBuffer(this.children, buffer)
-  }
-}
-
-export const jsx = (
-  tag: string | Function,
-  props: Props | null,
-  ...children: (string | number | HtmlEscapedString)[]
-): JSXNode => {
-  props ??= {}
-  if (children.length) {
-    props.children = children.length === 1 ? children[0] : children
-  }
-
-  const key = props.key
-  delete props['key']
-
-  const node = jsxFn(tag, props, children)
-  node.key = key
-  return node
-}
-
-let initDomRenderer = false
-export const jsxFn = (
-  tag: string | Function,
-  props: Props,
-  children: (string | number | HtmlEscapedString)[]
-): JSXNode => {
-  if (!initDomRenderer) {
-    for (const k in domRenderers) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(intrinsicElementTags[k as keyof typeof intrinsicElementTags] as any)[DOM_RENDERER] =
-        domRenderers[k]
-    }
-    initDomRenderer = true
-  }
-
-  if (typeof tag === 'function') {
-    return new JSXFunctionNode(tag, props, children)
-  } else if (intrinsicElementTags[tag as keyof typeof intrinsicElementTags]) {
-    return new JSXFunctionNode(
-      intrinsicElementTags[tag as keyof typeof intrinsicElementTags],
-      props,
-      children
-    )
-  } else if (tag === 'svg' || tag === 'head') {
-    nameSpaceContext ||= createContext('')
-    return new JSXNode(tag, props, [
-      new JSXFunctionNode(
-        nameSpaceContext,
-        {
-          value: tag,
-        },
-        children
-      ),
-    ])
-  } else {
-    return new JSXNode(tag, props, children)
-  }
-}
-
-const shallowEqual = (a: Props, b: Props): boolean => {
-  if (a === b) {
-    return true
-  }
-
-  const aKeys = Object.keys(a).sort()
-  const bKeys = Object.keys(b).sort()
-  if (aKeys.length !== bKeys.length) {
-    return false
-  }
-
-  for (let i = 0, len = aKeys.length; i < len; i++) {
-    if (
-      aKeys[i] === 'children' &&
-      bKeys[i] === 'children' &&
-      !a.children?.length &&
-      !b.children?.length
-    ) {
-      continue
-    } else if (a[aKeys[i]] !== b[aKeys[i]]) {
-      return false
-    }
-  }
-
-  return true
-}
-
-export const memo = <T>(
-  component: FC<T>,
-  propsAreEqual: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean = shallowEqual
-): FC<T> => {
-  let computed: ReturnType<FC<T>> = null
-  let prevProps: T | undefined = undefined
-  return ((props) => {
-    if (prevProps && !propsAreEqual(prevProps, props)) {
-      computed = null
-    }
-    prevProps = props
-    return (computed ||= component(props))
-  }) as FC<T>
-}
-
-export const Fragment = ({
-  children,
-}: {
-  key?: string
-  children?: Child | HtmlEscapedString
-}): HtmlEscapedString => {
-  return new JSXFragmentNode(
-    '',
-    {
-      children,
-    },
-    Array.isArray(children) ? children : children ? [children] : []
-  ) as never
-}
-
-export const isValidElement = (element: unknown): element is JSXNode => {
-  return !!(element && typeof element === 'object' && 'tag' in element && 'props' in element)
-}
-
-export const cloneElement = <T extends JSXNode | JSX.Element>(
-  element: T,
-  props: Partial<Props>,
-  ...children: Child[]
-): T => {
-  return jsx(
-    (element as JSXNode).tag,
-    { ...(element as JSXNode).props, ...props },
-    ...(children as (string | number | HtmlEscapedString)[])
-  ) as T
-}
-
-export const reactAPICompatVersion = '19.0.0-hono-jsx'

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

@@ -1,20 +0,0 @@
-import type { Child } from './base'
-
-export const toArray = (children: Child): Child[] =>
-  Array.isArray(children) ? children : [children]
-export const Children = {
-  map: (children: Child[], fn: (child: Child, index: number) => Child): Child[] =>
-    toArray(children).map(fn),
-  forEach: (children: Child[], fn: (child: Child, index: number) => void): void => {
-    toArray(children).forEach(fn)
-  },
-  count: (children: Child[]): number => toArray(children).length,
-  only: (_children: Child[]): Child => {
-    const children = toArray(_children)
-    if (children.length !== 1) {
-      throw new Error('Children.only() expects only one child')
-    }
-    return children[0]
-  },
-  toArray,
-}

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

@@ -1,195 +0,0 @@
-import { raw } from '../helper/html'
-import type { HtmlEscapedCallback, HtmlEscapedString } from '../utils/html'
-import { HtmlEscapedCallbackPhase, resolveCallback } from '../utils/html'
-import { DOM_RENDERER } from './constants'
-import { ErrorBoundary as ErrorBoundaryDomRenderer } from './dom/components'
-import type { HasRenderToDom } from './dom/render'
-import type { Child, FC, PropsWithChildren } from './'
-
-let errorBoundaryCounter = 0
-
-export const childrenToString = async (children: Child[]): Promise<HtmlEscapedString[]> => {
-  try {
-    return children
-      .flat()
-      .map((c) => (c == null || typeof c === 'boolean' ? '' : c.toString())) as HtmlEscapedString[]
-  } catch (e) {
-    if (e instanceof Promise) {
-      await e
-      return childrenToString(children)
-    } else {
-      throw e
-    }
-  }
-}
-
-export type ErrorHandler = (error: Error) => void
-export type FallbackRender = (error: Error) => Child
-
-/**
- * @experimental
- * `ErrorBoundary` is an experimental feature.
- * The API might be changed.
- */
-export const ErrorBoundary: FC<
-  PropsWithChildren<{
-    fallback?: Child
-    fallbackRender?: FallbackRender
-    onError?: ErrorHandler
-  }>
-> = async ({ children, fallback, fallbackRender, onError }) => {
-  if (!children) {
-    return raw('')
-  }
-
-  if (!Array.isArray(children)) {
-    children = [children]
-  }
-
-  let fallbackStr: string | undefined
-  const fallbackRes = (error: Error): HtmlEscapedString => {
-    onError?.(error)
-    return (fallbackStr || fallbackRender?.(error) || '').toString() as HtmlEscapedString
-  }
-  let resArray: HtmlEscapedString[] | Promise<HtmlEscapedString[]>[] = []
-  try {
-    resArray = children.map((c) =>
-      c == null || typeof c === 'boolean' ? '' : c.toString()
-    ) as HtmlEscapedString[]
-  } catch (e) {
-    fallbackStr = await fallback?.toString()
-    if (e instanceof Promise) {
-      resArray = [
-        e.then(() => childrenToString(children as Child[])).catch((e) => fallbackRes(e)),
-      ] as Promise<HtmlEscapedString[]>[]
-    } else {
-      resArray = [fallbackRes(e as Error)]
-    }
-  }
-
-  if (resArray.some((res) => (res as {}) instanceof Promise)) {
-    fallbackStr ||= await fallback?.toString()
-    const index = errorBoundaryCounter++
-    const replaceRe = RegExp(`(<template id="E:${index}"></template>.*?)(.*?)(<!--E:${index}-->)`)
-    const caught = false
-    const catchCallback = ({ error, buffer }: { error: Error; buffer?: [string] }) => {
-      if (caught) {
-        return ''
-      }
-
-      const fallbackResString = fallbackRes(error)
-      if (buffer) {
-        buffer[0] = buffer[0].replace(replaceRe, fallbackResString)
-      }
-      return buffer
-        ? ''
-        : `<template data-hono-target="E:${index}">${fallbackResString}</template><script>
-((d,c,n) => {
-c=d.currentScript.previousSibling
-d=d.getElementById('E:${index}')
-if(!d)return
-do{n=d.nextSibling;n.remove()}while(n.nodeType!=8||n.nodeValue!='E:${index}')
-d.replaceWith(c.content)
-})(document)
-</script>`
-    }
-
-    let error: unknown
-    const promiseAll = Promise.all(resArray).catch((e) => (error = e))
-    return raw(`<template id="E:${index}"></template><!--E:${index}-->`, [
-      ({ phase, buffer, context }) => {
-        if (phase === HtmlEscapedCallbackPhase.BeforeStream) {
-          return
-        }
-        return promiseAll
-          .then(async (htmlArray: HtmlEscapedString[]) => {
-            if (error) {
-              throw error
-            }
-            htmlArray = htmlArray.flat()
-            const content = htmlArray.join('')
-            let html = buffer
-              ? ''
-              : `<template data-hono-target="E:${index}">${content}</template><script>
-((d,c) => {
-c=d.currentScript.previousSibling
-d=d.getElementById('E:${index}')
-if(!d)return
-d.parentElement.insertBefore(c.content,d.nextSibling)
-})(document)
-</script>`
-
-            if (htmlArray.every((html) => !(html as HtmlEscapedString).callbacks?.length)) {
-              if (buffer) {
-                buffer[0] = buffer[0].replace(replaceRe, content)
-              }
-              return html
-            }
-
-            if (buffer) {
-              buffer[0] = buffer[0].replace(
-                replaceRe,
-                (_all, pre, _, post) => `${pre}${content}${post}`
-              )
-            }
-
-            const callbacks = htmlArray
-              .map((html) => (html as HtmlEscapedString).callbacks || [])
-              .flat()
-
-            if (phase === HtmlEscapedCallbackPhase.Stream) {
-              html = await resolveCallback(
-                html,
-                HtmlEscapedCallbackPhase.BeforeStream,
-                true,
-                context
-              )
-            }
-
-            let resolvedCount = 0
-            const promises = callbacks.map<HtmlEscapedCallback>(
-              (c) =>
-                (...args) =>
-                  c(...args)
-                    ?.then((content) => {
-                      resolvedCount++
-
-                      if (buffer) {
-                        if (resolvedCount === callbacks.length) {
-                          buffer[0] = buffer[0].replace(replaceRe, (_all, _pre, content) => content)
-                        }
-                        buffer[0] += content
-                        return raw('', (content as HtmlEscapedString).callbacks)
-                      }
-
-                      return raw(
-                        content +
-                          (resolvedCount !== callbacks.length
-                            ? ''
-                            : `<script>
-((d,c,n) => {
-d=d.getElementById('E:${index}')
-if(!d)return
-n=d.nextSibling
-while(n.nodeType!=8||n.nodeValue!='E:${index}'){n=n.nextSibling}
-n.remove()
-d.remove()
-})(document)
-</script>`),
-                        (content as HtmlEscapedString).callbacks
-                      )
-                    })
-                    .catch((error) => catchCallback({ error, buffer }))
-            )
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            return raw(html, promises as any)
-          })
-          .catch((error) => catchCallback({ error, buffer }))
-      },
-    ])
-  } else {
-    return raw(resArray.join(''))
-  }
-}
-;(ErrorBoundary as HasRenderToDom)[DOM_RENDERER] = ErrorBoundaryDomRenderer

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

@@ -1,5 +0,0 @@
-export const DOM_RENDERER = Symbol('RENDERER')
-export const DOM_ERROR_HANDLER = Symbol('ERROR_HANDLER')
-export const DOM_STASH = Symbol('STASH')
-export const DOM_INTERNAL_TAG = Symbol('INTERNAL')
-export const PERMALINK = Symbol('PERMALINK')

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

@@ -1,50 +0,0 @@
-import { raw } from '../helper/html'
-import type { HtmlEscapedString } from '../utils/html'
-import { JSXFragmentNode } from './base'
-import { DOM_RENDERER } from './constants'
-import { createContextProviderFunction } from './dom/context'
-import type { FC, PropsWithChildren } from './'
-
-export interface Context<T> extends FC<PropsWithChildren<{ value: T }>> {
-  values: T[]
-  Provider: FC<PropsWithChildren<{ value: T }>>
-}
-
-export const globalContexts: Context<unknown>[] = []
-
-export const createContext = <T>(defaultValue: T): Context<T> => {
-  const values = [defaultValue]
-  const context: Context<T> = ((props): HtmlEscapedString | Promise<HtmlEscapedString> => {
-    values.push(props.value)
-    let string
-    try {
-      string = props.children
-        ? (Array.isArray(props.children)
-            ? new JSXFragmentNode('', {}, props.children)
-            : props.children
-          ).toString()
-        : ''
-    } finally {
-      values.pop()
-    }
-
-    if (string instanceof Promise) {
-      return string.then((resString) => raw(resString, (resString as HtmlEscapedString).callbacks))
-    } else {
-      return raw(string)
-    }
-  }) as Context<T>
-  context.values = values
-  context.Provider = context
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  ;(context as any)[DOM_RENDERER] = createContextProviderFunction(values)
-
-  globalContexts.push(context as Context<unknown>)
-
-  return context
-}
-
-export const useContext = <T>(context: Context<T>): T => {
-  return context.values.at(-1) as T
-}