ranuts 0.1.0-alpha → 0.1.0-alpha.1

package/src/sort/insert.ts

@@ -0,0 +1,20 @@
+/**
+ * @description: 插入排序，维护一个有序的数组，将后面的数字插入到前面的有序数组中国
+ * @param {Array} list
+ * @return {Array}
+ */
+const insert = (list: Array<string>): Array<string> => {
+  const { length } = list
+  for (let i = 1; i < length; i++) {
+    let preIndex = i - 1
+    const current = list[i]
+    while (preIndex >= 0 && list[preIndex] > current) {
+      list[preIndex + 1] = list[preIndex]
+      preIndex--
+    }
+    list[preIndex + 1] = current
+  }
+  return list
+}
+
+export default insert

package/src/sort/merge.ts

@@ -0,0 +1,35 @@
+const combine = (left: Array<number>, right: Array<number>) => {
+  const list: Array<number> = []
+  while (left.length > 0 && right.length > 0) {
+    if (left[0] <= right[0]) {
+      list.push(left.shift() as number)
+    } else {
+      list.push(right.shift() as number)
+    }
+  }
+
+  while (left.length) {
+    list.push(left.shift() as number)
+  }
+  while (right.length) {
+    list.push(right.shift() as number)
+  }
+  return list
+}
+/**
+ * @description: 归并排序
+ * @param {Array} list
+ * @return {Array}
+ */
+const merge = (list: Array<number>): Array<number> => {
+  const { length } = list
+  if (length < 2) {
+    return list
+  }
+  const middle = Math.floor(length / 2)
+  const left = list.slice(0, middle)
+  const right = list.slice(middle)
+  return combine(merge(left), merge(right))
+}
+
+export default merge

package/src/sort/quick.ts

@@ -0,0 +1,50 @@
+/**
+ * @description: 设置基准值pivot
+ * @param {Array} list
+ * @param {number} left
+ * @param {number} right
+ * @return {number} index
+ */
+const partition = (list: Array<number>, left: number, right: number) => {
+  const pivot = left
+  let index = pivot + 1
+  for (let i = index; i <= right; i++) {
+    if (list[i] < list[pivot]) {
+      const temp = list[i]
+      list[i] = list[index]
+      list[index] = temp
+      index++
+    }
+  }
+  const temp = list[pivot]
+  list[pivot] = list[index - 1]
+  list[index - 1] = temp
+  return index - 1
+}
+/**
+ * @description: 不断分区，设置基准值
+ * @param {Array} list
+ * @param {number} left
+ * @param {number} right
+ * @return {Array}
+ */
+const combine = (list: Array<number>, left: number, right: number) => {
+  let partitionIndex
+  if (left < right) {
+    partitionIndex = partition(list, left, right)
+    combine(list, left, partitionIndex - 1)
+    combine(list, partitionIndex + 1, right)
+  }
+  return list
+}
+/**
+ * @description: 快速排序
+ * @param {Array} list
+ * @return {Array}
+ */
+const quick = (list: Array<number>): Array<number> => {
+  const { length } = list
+  return combine(list, 0, length - 1)
+}
+
+export default quick

package/src/sort/radix.ts

@@ -0,0 +1,11 @@
+/**
+ * @description: 基数排序
+ * @param {Array<number>} list
+ * @return {Array<number>} 
+ */
+const radix = (list: Array<number>): Array<number> => {
+    return list
+}
+
+export default radix
+  

package/src/sort/randomArray.ts

@@ -0,0 +1,21 @@
+/**
+ * @description: 通过数组长度，数组最大值，数组的最小值随机生成数组
+ * @param {number} length
+ * @param {number} min
+ * @param {number} max
+ * @return {Array<number>}
+ */
+const randomArray = (
+  length: number = 10,
+  min: number = 0,
+  max: number = min + 100,
+): Array<number> => {
+  if (min > max) {
+    throw new Error('max must be max min')
+  }
+  return Array.from({ length }, (_) =>
+    Math.floor(Math.random() * (max - min) + min),
+  )
+}
+
+export default randomArray

package/src/sort/select.ts

@@ -0,0 +1,23 @@
+/**
+ * @description: 选择排序，遍历一遍，找到最小值，放到最前面，重复n次上述操作。
+ * @param {Array} list
+ * @return {Array}
+ */
+const select = (list: Array<number>): Array<number> => {
+  const { length } = list
+  for (let i = 0; i < length; i++) {
+    let minIndex = i
+    for (let j = i + 1; j < length; j++) {
+      if (list[j] <= list[minIndex]) {
+        minIndex = j
+      }
+    }
+
+    const temp = list[i]
+    list[i] = list[minIndex]
+    list[minIndex] = temp
+  }
+  return list
+}
+
+export default select

package/src/sort/shell.ts

@@ -0,0 +1,22 @@
+/**
+ * @description: 希尔排序，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
+ * @param {Array} list
+ * @return {Array}
+ */
+const shell = (list: Array<number>): Array<number> => {
+  const { length } = list
+  for (let gap = Math.floor(length / 2); gap > 0; gap = Math.floor(gap / 2)) {
+    for (let i = gap; i < length; i++) {
+      let j = i
+      const current = list[i]
+      while (j - gap >= 0 && current < list[j - gap]) {
+        list[j] = list[j - gap]
+        j = j - gap
+      }
+      list[j] = current
+    }
+  }
+  return list
+}
+
+export default shell

package/src/utils/compose.ts

@@ -0,0 +1,37 @@
+export type Next = () => Promise<never> | Promise<void>
+
+type Middleware<T> = (context: T, next: Next) => any
+
+type ComposedMiddleware<T> = (context: T, next?: Next) => Promise<void>
+/**
+ * @description: 将异步函数转化为同步的方式进行执行
+ * @param {Array} middleware
+ * @return {*}
+ */
+export function compose<T>(
+  middleware: Array<Middleware<T>>,
+): ComposedMiddleware<T> {
+  if (!Array.isArray(middleware))
+    throw new TypeError('Middleware stack must be an array!')
+  for (const fn of middleware) {
+    if (typeof fn !== 'function')
+      throw new TypeError('Middleware must be composed of functions!')
+  }
+  return function (context, next) {
+    let index = -1
+    return dispatch(0)
+    function dispatch(i: number): Promise<never> | Promise<void> {
+      if (i <= index)
+        return Promise.reject(new Error('next() called multiple times'))
+      index = i
+      let fn = middleware[i]
+      if (i === middleware.length && next) fn = next
+      if (!fn) return Promise.resolve()
+      try {
+        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)))
+      } catch (err) {
+        return Promise.reject(err)
+      }
+    }
+  }
+}

package/src/utils/filterObj.ts

@@ -0,0 +1,21 @@
+/**
+ * @description: 过滤对象的属性，去除对象中在list数组里面有的属性，返回一个新对象，一般是用于去除空字符和null
+ * @param {Object} obj 传入对象
+ * @param {Array} list 传入数组
+ * @return {Object}
+ */
+
+const filterObj = (
+  obj: Record<string | symbol, any>,
+  list: Array<string | symbol>,
+): Record<string | symbol, any> => {
+  const result: Record<string | symbol, any> = {}
+  Object.keys(obj).forEach((item) => {
+    if (!list.includes(obj[item])) {
+      result[item] = obj[item]
+    }
+  })
+  return result
+}
+
+export default filterObj

package/src/utils/mergeObj.ts

@@ -0,0 +1,12 @@
+type Obj = Record<string, any>
+
+const merge = (a: Obj, b?: Obj): Obj => {
+  if (a && b) {
+    for (const key in b) {
+      a[key] = b[key]
+    }
+  }
+  return a
+}
+
+export default merge

package/src/utils/startTask.ts

@@ -0,0 +1,15 @@
+import { hrtime } from 'node:process'
+
+const startTask = (): symbol => {
+  if(typeof window !== 'undefined'){
+    const startTime = window.performance.now()
+    return Symbol.for(`${startTime}`)
+  }
+  if(typeof process !== 'undefined'){
+    const startTime = hrtime.bigint()
+    return Symbol.for(`${startTime}`)
+  }
+  return Symbol.for(`${Date.now()}`)
+}
+
+export default startTask

package/src/utils/str2Xml.ts

@@ -0,0 +1,26 @@
+/**
+ * @description: 传入字符串和指定的格式，将字符串转成xml
+ * @param {string} xmlStr
+ * @param {DOMParserSupportedType} format
+ * @return {Document}
+ */
+const str2Xml = (
+  xmlStr: string,
+  format: DOMParserSupportedType = 'text/xml',
+): HTMLElement | undefined => {
+  if (window.DOMParser)
+    return new window.DOMParser().parseFromString(xmlStr, format)
+      .documentElement
+  if (
+    typeof window.ActiveXObject !== 'undefined' &&
+    new window.ActiveXObject('Microsoft.XMLDOM')
+  ) {
+    const xmlDoc = new window.ActiveXObject('Microsoft.XMLDOM')
+    xmlDoc.async = 'false'
+    xmlDoc.loadXML(xmlStr)
+    return xmlDoc
+  }
+  return undefined
+}
+
+export default str2Xml

package/src/utils/taskEnd.ts

@@ -0,0 +1,14 @@
+import { hrtime } from 'node:process'
+
+const taskEnd = (symbol: symbol): number | bigint => {
+  const startTime = Symbol.keyFor(symbol)
+  if (typeof window !== 'undefined' && startTime) {
+    return window.performance.now() - Number(startTime)
+  }
+  if (typeof process !== 'undefined' && startTime) {
+    return hrtime.bigint() - BigInt(startTime)
+  }
+  return Date.now() - Number(startTime)
+}
+
+export default taskEnd

package/src/vnode/h.ts

@@ -0,0 +1,108 @@
+import type {
+  VNode,
+  VNodeChildElement,
+  VNodeChildren,
+  VNodeData,
+  VNodes,
+} from './vnode'
+import { vnode } from './vnode'
+// 类型判断
+import * as is from './is'
+
+export function addNS(
+  data: VNodeData,
+  children: Array<VNode | string | number> |undefined,
+  sel: string | undefined,
+): void {
+  data.ns = 'http://www.w3.org/2000/svg'
+  if (sel !== 'foreignObject' && children !== undefined) {
+    for (let i = 0; i < children.length; ++i) {
+      const child = children[i]
+      if (typeof child === 'string' || typeof child === 'number') continue
+      const childData = child.data
+      if (childData !== undefined) {
+        addNS(childData, child.children as VNodes, child.sel)
+      }
+    }
+  }
+}
+
+// h 函数的重载
+export function h(sel: string): VNode
+export function h(sel: string, data: VNodeData | null): VNode
+export function h(sel: string, children: VNodeChildren): VNode
+export function h(
+  sel: string,
+  data: VNodeData | null,
+  children: VNodeChildren,
+): VNode
+export function h(
+  sel: string,
+  b?: VNodeData | null | VNodeChildren,
+  c?: VNodeChildren,
+): VNode {
+  // 缓存 VNode 数据
+  let data: VNodeData = {}
+  // 缓存 children 数据
+  let children: VNodeChildElement[] | undefined = undefined
+  // 缓存文本数据
+  let text: string | number | undefined
+  // 用于缓存遍历children的index
+  let i: number
+
+  // 处理参数,实现重载的机制
+  if (c !== undefined) {
+    // 处理三个参数的情况
+    // sel、data、children/text
+    if (b != null) {
+      data = b as VNodeData
+    }
+    if (is.array(c)) {
+      children = c
+      // 如果c是字符串或者数字
+    } else if (is.primitive(c)) {
+      text = c
+      // 如果c是VNode
+    } else if (c && c.sel) {
+      children = [c]
+    }
+  } else if (b !== undefined && b != null) {
+    // 处理两个参数的情况
+    // 如果b是数组
+    if (is.array(b)) {
+      children = b
+      // 如果b是字符串或数字
+    } else if (is.primitive(b)) {
+      text = b
+    } else {
+      // 这里由于b没有使用any类型，所以需要进一步判断b是否为VNode
+      if (is.isVnode(b)) {
+        children = [b]
+      } else {
+        data = b
+      }
+    }
+  }
+  // 处理 children 中的原始值(string/number)
+  if (typeof children !== 'undefined') {
+    for (i = 0; i < children.length; ++i) {
+      // 如果 child 是string/number,创建文本节点
+      // 这里由于children没有使用any类型，所以需要进一步判断children[i]是否为string | number
+      // 不能直接使用children[i],所以使用msg缓存
+      const msg = children[i]
+      if (is.primitive(msg)) {
+        children[i] = vnode(undefined, undefined, undefined, msg, undefined)
+      }
+    }
+  }
+  if (
+    sel[0] === 's' &&
+    sel[1] === 'v' &&
+    sel[2] === 'g' &&
+    (sel.length === 3 || sel[3] === '.' || sel[3] === '#')
+  ) {
+    addNS(data, children, sel)
+  }
+  // 符合VNode
+  return vnode(sel, data, children, text, undefined)
+}

package/src/vnode/hooks.ts

@@ -0,0 +1,25 @@
+import type { VNode } from "./vnode";
+
+export type PreHook = () => any;
+export type InitHook = (vNode: VNode) => any;
+export type CreateHook = (emptyVNode: VNode, vNode: VNode) => any;
+export type InsertHook = (vNode: VNode) => any;
+export type PrePatchHook = (oldVNode: VNode, vNode: VNode) => any;
+export type UpdateHook = (oldVNode: VNode, vNode: VNode) => any;
+export type PostPatchHook = (oldVNode: VNode, vNode: VNode) => any;
+export type DestroyHook = (vNode: VNode) => any;
+export type RemoveHook = (vNode: VNode, removeCallback: () => void) => any;
+export type PostHook = () => any;
+
+export interface Hooks {
+  pre?: PreHook;
+  init?: InitHook;
+  create?: CreateHook;
+  insert?: InsertHook;
+  prepatch?: PrePatchHook;
+  update?: UpdateHook;
+  postpatch?: PostPatchHook;
+  destroy?: DestroyHook;
+  remove?: RemoveHook;
+  post?: PostHook;
+}

package/src/vnode/htmlDomApi.ts

@@ -0,0 +1,199 @@
+export interface Fragment extends DocumentFragment {
+  parent: Node | null
+  firstChildNode: ChildNode | null
+  lastChildNode: ChildNode | null
+}
+
+export interface DOMAPI {
+  // 创建元素节点
+  createElement: (tagName: any, options?: ElementCreationOptions) => HTMLElement
+  createElementNS: (
+    namespaceURI: string,
+    qualifiedName: string,
+    options?: ElementCreationOptions,
+  ) => Element
+  /**
+   * @experimental
+   * @todo Make it required when the fragment is considered stable.
+   */
+  createDocumentFragment?: () => Fragment
+  // 创建文本节点
+  createTextNode: (text: string) => Text
+  // 创建注释节点
+  createComment: (text: string) => Comment
+  // 在指定的已有子节点之前插入新的子节点。
+  insertBefore: (
+    parentNode: Node,
+    newNode: Node,
+    referenceNode: Node | null,
+  ) => void
+  // 删除子节点
+  removeChild: (node: Node, child: Node) => void
+  // 添加子节点
+  appendChild: (node: Node, child: Node) => void
+  // 获取元素父节点
+  parentNode: (node: Node) => Node | null
+  // 获取元素紧跟的节点
+  nextSibling: (node: Node) => Node | null
+  // 获取元素标签名
+  tagName: (elm: Element) => string
+  // 设置元素文本内容
+  setTextContent: (node: Node, text: string | null) => void
+  // 获取元素文本内容
+  getTextContent: (node: Node) => string | null
+  // 判定是否为元素节点
+  isElement: (node: Node) => node is Element
+  // 判定是否为文本节点
+  isText: (node: Node) => node is Text
+  // 判定是否为注释节点
+  isComment: (node: Node) => node is Comment
+  /**
+   * @experimental
+   * @todo Make it required when the fragment is considered stable.
+   */
+  isDocumentFragment?: (node: Node) => node is DocumentFragment
+}
+
+function createElement(
+  tagName: any,
+  options?: ElementCreationOptions,
+): HTMLElement {
+  return document.createElement(tagName, options)
+}
+
+function createElementNS(
+  namespaceURI: string,
+  qualifiedName: string,
+  options?: ElementCreationOptions,
+): Element {
+  return document.createElementNS(namespaceURI, qualifiedName, options)
+}
+
+function createDocumentFragment(): Fragment {
+  return parseFragment(document.createDocumentFragment())
+}
+
+function createTextNode(text: string): Text {
+  return document.createTextNode(text)
+}
+
+function createComment(text: string): Comment {
+  return document.createComment(text)
+}
+
+function insertBefore(
+  parentNode: Node,
+  newNode: Node,
+  referenceNode: Node | null,
+): void {
+  if (isDocumentFragment(parentNode)) {
+    let node: Node | null = parentNode
+    while (node && isDocumentFragment(node)) {
+      const fragment = parseFragment(node)
+      node = fragment.parent
+    }
+    parentNode = node ?? parentNode
+  }
+  if (isDocumentFragment(newNode)) {
+    newNode = parseFragment(newNode, parentNode)
+  }
+  if (referenceNode && isDocumentFragment(referenceNode)) {
+    referenceNode = parseFragment(referenceNode).firstChildNode
+  }
+  parentNode.insertBefore(newNode, referenceNode)
+}
+
+function removeChild(node: Node, child: Node): void {
+  node.removeChild(child)
+}
+
+function appendChild(node: Node, child: Node): void {
+  if (isDocumentFragment(child)) {
+    child = parseFragment(child, node)
+  }
+  node.appendChild(child)
+}
+
+function parentNode(node: Node): Node | null {
+  if (isDocumentFragment(node)) {
+    while (node && isDocumentFragment(node)) {
+      const fragment = parseFragment(node)
+      node = fragment.parent as Node
+    }
+    return node ?? null
+  }
+  return node.parentNode
+}
+
+function nextSibling(node: Node): Node | null {
+  if (isDocumentFragment(node)) {
+    const fragment = parseFragment(node)
+    const parent = parentNode(fragment)
+    if (parent && fragment.lastChildNode) {
+      const children = Array.from(parent.childNodes)
+      const index = children.indexOf(fragment.lastChildNode)
+      return children[index + 1] ?? null
+    }
+    return null
+  }
+  return node.nextSibling
+}
+
+function tagName(elm: Element): string {
+  return elm.tagName
+}
+
+function setTextContent(node: Node, text: string | null): void {
+  node.textContent = text
+}
+
+function getTextContent(node: Node): string | null {
+  return node.textContent
+}
+
+function isElement(node: Node): node is Element {
+  return node.nodeType === 1
+}
+
+function isText(node: Node): node is Text {
+  return node.nodeType === 3
+}
+
+function isComment(node: Node): node is Comment {
+  return node.nodeType === 8
+}
+
+function isDocumentFragment(node: Node): node is DocumentFragment {
+  return node.nodeType === 11
+}
+
+function parseFragment(
+  fragmentNode: DocumentFragment,
+  parentNode?: Node | null,
+): Fragment {
+  const fragment = fragmentNode as Fragment
+  fragment.parent ??= parentNode ?? null
+  fragment.firstChildNode ??= fragmentNode.firstChild
+  fragment.lastChildNode ??= fragmentNode.lastChild
+  return fragment
+}
+
+export const htmlDomApi: DOMAPI = {
+  createElement,
+  createElementNS,
+  createTextNode,
+  createDocumentFragment,
+  createComment,
+  insertBefore,
+  removeChild,
+  appendChild,
+  parentNode,
+  nextSibling,
+  tagName,
+  setTextContent,
+  getTextContent,
+  isElement,
+  isText,
+  isComment,
+  isDocumentFragment,
+}