@tarojs/plugin-platform-harmony-ets 3.7.0-alpha.27

package/dist/runtime-framework/solid/reconciler/h.ts

@@ -0,0 +1,132 @@
+import { TaroNode } from '@tarojs/runtime'
+import { children as solidChildren, createRenderEffect, onCleanup, splitProps } from 'solid-js'
+
+import { createElement, createTextNode, effect, insert, insertNode, setProp } from './render'
+
+import type { Accessor } from 'solid-js'
+import type { ResolvedChildren } from 'solid-js/types/reactive/signal'
+
+export type Component = (props?: any) => TaroNode
+
+type Children =
+  | undefined
+  | string
+  | number
+  | TaroNode
+  | TaroNode[]
+  | Component
+  | Component[]
+  | Accessor<ResolvedChildren>
+  | (() => Component[])
+
+export function h(tagName: string, props?: any, children?: Children) {
+  if (typeof tagName !== 'string') {
+    throw Error(`h function cant create ele for ${tagName}`)
+  }
+  const ele = createElement(tagName)
+  const [local, otherProps] = splitProps(props, ['ref', 'children'])
+
+  setProps(ele, otherProps)
+
+  if (local.ref) {
+    createRenderEffect(() => {
+      if (typeof local.ref === 'function') {
+        local.ref(ele)
+      } else {
+        local.ref = ele
+      }
+    })
+  }
+
+  // get 的处理
+  if (local.hasOwnProperty('children')) {
+    const descriptor = Object.getOwnPropertyDescriptor(local, 'children')
+    if (descriptor?.get) {
+      children = solidChildren(() => local.children)
+    } else {
+      children = local.children
+    }
+  }
+  insertNodes(ele, children)
+
+  return ele
+}
+
+function setProps(ele: TaroNode, otherProps: Record<string, any> = {}) {
+  const desc = { ...otherProps }
+  const plain_keys = Object.keys(desc).filter((key) => {
+    if (desc[key]?.get) {
+      return false
+    }
+    return true
+  })
+  const [plainProps, getterValues] = splitProps(otherProps, plain_keys)
+
+  // 普通属性直接赋值
+  if (Object.keys(plainProps)?.length) {
+    for (const key in plainProps) {
+      setProp(ele, key, plainProps[key])
+    }
+  }
+
+  // 特殊属性 放到createRenderEffect中
+  if (Object.keys(getterValues)?.length) {
+    let preProps = {} as typeof getterValues
+    effect(() => {
+      for (const key in getterValues) {
+        const val = getterValues[key]
+
+        if (val === preProps[key]) {
+          continue
+        }
+        setProp(ele, key, val, preProps[key])
+        preProps[key] = val
+      }
+    })
+    onCleanup(() => {
+      preProps = {}
+    })
+  }
+}
+
+function insertNodes(parent: TaroNode, children: Children) {
+  if (children === undefined) {
+    return
+  }
+
+  let list = [] as TaroNode[] | (() => TaroNode)[]
+  if (!Array.isArray(children)) {
+    list = [children] as TaroNode[] | (() => TaroNode)[]
+  } else {
+    list = children
+  }
+  for (let i = 0; i < list.length; i++) {
+    const child = list[i]
+    const type = typeof child
+    if (type === 'function') {
+      insert(parent, child, null)
+      continue
+    }
+    if (Array.isArray(child)) {
+      insertNodes(parent, child)
+      continue
+    }
+
+    if (child instanceof TaroNode) {
+      insertNode(parent, child)
+      continue
+    }
+
+    if (type === 'string') {
+      const node = createTextNode(child as unknown as string)
+      insertNode(parent, node)
+      continue
+    }
+
+    if (type === 'number' || type === 'boolean' || child instanceof Date || child instanceof RegExp) {
+      const node = createTextNode(child.toString())
+      insertNode(parent, node)
+      continue
+    }
+  }
+}

package/dist/runtime-framework/solid/reconciler/index.ts

@@ -0,0 +1,3 @@
+export * from './h'
+export * from './render'
+export * from './use'

package/dist/runtime-framework/solid/reconciler/props.ts

@@ -0,0 +1,151 @@
+import { convertNumber2PX, FormElement } from '@tarojs/runtime'
+import { capitalize, internalComponents, isFunction, isNumber, isObject, isString, toCamelCase } from '@tarojs/shared'
+
+import type { Style, TaroElement } from '@tarojs/runtime'
+
+export type Props = Record<string, unknown>
+
+function isEventName (s: string) {
+  return s[0] === 'o' && s[1] === 'n'
+}
+
+const IS_NON_DIMENSIONAL = /max|aspect|acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i
+
+export function updateProps (dom: TaroElement, oldProps: Props, newProps: Props) {
+  const updatePayload = getUpdatePayload(dom, oldProps, newProps)
+  if (updatePayload){
+    updatePropsByPayload(dom, oldProps, updatePayload)
+  }
+}
+
+export function updatePropsByPayload (dom: TaroElement, oldProps: Props, updatePayload: any[]){
+  for (let i = 0; i < updatePayload.length; i += 2){ // key, value 成对出现
+    const key = updatePayload[i]; const newProp = updatePayload[i+1]; const oldProp = oldProps[key]
+    setProperty(dom, key, newProp, oldProp)
+  }
+}
+
+export function getUpdatePayload (dom: TaroElement, oldProps: Props, newProps: Props){
+  let i: string
+  let updatePayload: any[] | null = null
+
+  for (i in oldProps) {
+    if (!(i in newProps)) {
+      (updatePayload = updatePayload || []).push(i, null)
+    }
+  }
+  const isFormElement = dom instanceof FormElement
+  for (i in newProps) {
+    if (oldProps[i] !== newProps[i] || (isFormElement && i === 'value')) {
+      (updatePayload = updatePayload || []).push(i, newProps[i])
+    }
+  }
+
+  return updatePayload
+}
+
+// function eventProxy (e: CommonEvent) {
+//   const el = document.getElementById(e.currentTarget.id)
+//   const handlers = el!.__handlers[e.type]
+//   handlers[0](e)
+// }
+
+function setEvent (dom: TaroElement, name: string, value: unknown, oldValue?: unknown) {
+  const isCapture = name.endsWith('Capture')
+  let eventName = name.toLowerCase().slice(2)
+  if (isCapture) {
+    eventName = eventName.slice(0, -7)
+  }
+
+  const compName = capitalize(toCamelCase(dom.tagName.toLowerCase()))
+
+  if (eventName === 'click' && compName in internalComponents) {
+    eventName = 'tap'
+  }
+
+  if (isFunction(value)) {
+    const isHarmony = process.env.TARO_PLATFORM === 'harmony'
+    if (oldValue) {
+      dom.removeEventListener(eventName, oldValue as any, !isHarmony ? false : undefined)
+      dom.addEventListener(eventName, value, !isHarmony ? { isCapture, sideEffect: false } : undefined)
+    } else {
+      dom.addEventListener(eventName, value, !isHarmony ? isCapture : undefined)
+    }
+  } else {
+    dom.removeEventListener(eventName, oldValue as any)
+  }
+}
+
+function setStyle (style: Style, key: string, value: string | number) {
+  if (key[0] === '-') {
+    style.setProperty(key, value.toString())
+    // css variables need not further judgment
+    return
+  }
+
+  style[key] =
+    isNumber(value) && IS_NON_DIMENSIONAL.test(key) === false
+      ? convertNumber2PX(value)
+      : value == null
+        ? ''
+        : value
+}
+
+type StyleValue = Record<string, string | number>
+interface DangerouslySetInnerHTML {
+  __html?: string
+}
+
+export function setProperty (dom: TaroElement, name: string, value: unknown, oldValue?: unknown) {
+  name = name === 'className' ? 'class' : name
+
+  if (
+    name === 'key' ||
+    name === 'children' ||
+    name === 'ref'
+  ) {
+    // skip
+  } else if (name === 'style') {
+    const style = dom.style
+    if (isString(value)) {
+      style.cssText = value
+    } else {
+      if (isString(oldValue)) {
+        style.cssText = ''
+        oldValue = null
+      }
+
+      if (isObject<StyleValue>(oldValue)) {
+        for (const i in oldValue) {
+          if (!(value && i in (value as StyleValue))) {
+            setStyle(style, i, '')
+          }
+        }
+      }
+
+      if (isObject<StyleValue>(value)) {
+        for (const i in value) {
+          if (!oldValue || value[i] !== (oldValue as StyleValue)[i]) {
+            setStyle(style, i, value[i])
+          }
+        }
+      }
+    }
+  } else if (isEventName(name)) {
+    setEvent(dom, name, value, oldValue)
+  } else if (name === 'dangerouslySetInnerHTML') {
+    const newHtml = (value as DangerouslySetInnerHTML)?.__html ?? ''
+    const oldHtml = (oldValue as DangerouslySetInnerHTML)?.__html ?? ''
+    if (newHtml || oldHtml) {
+      if (oldHtml !== newHtml) {
+        dom.innerHTML = newHtml
+      }
+    }
+  } else if (!isFunction(value)) {
+    if (value == null) {
+      dom.removeAttribute(name)
+    } else {
+      dom.setAttribute(name, value as string)
+    }
+  }
+}

package/dist/runtime-framework/solid/reconciler/render.ts

@@ -0,0 +1,61 @@
+import TaroText from '@tarojs/components/text'
+import { document } from '@tarojs/runtime'
+import { createRenderer } from 'solid-js/universal'
+
+import { h } from './h'
+import { setProperty } from './props'
+
+import type { TaroElement, TaroNode } from '@tarojs/runtime'
+
+const renderer = createRenderer<TaroNode>({
+  createElement(type: string) {
+    return document.createElement(type)
+  },
+  createTextNode(text) {
+    return document.createTextNode(text)
+  },
+  replaceText(textNode: typeof TaroText, value) {
+    textNode.textContent = value
+  },
+  setProperty(node: TaroElement, name: string, value, prev) {
+    setProperty(node, name, value, prev)
+  },
+  insertNode(parent, node, anchor) {
+    parent.insertBefore(node, anchor)
+  },
+  isTextNode(node: TaroNode) {
+    if (typeof node === 'string') {
+      return true
+    }
+    return node instanceof TaroText
+  },
+  removeNode(parent: TaroElement, node: TaroElement) {
+    parent.removeChild(node)
+  },
+  getParentNode(node: TaroNode) {
+    return node.parentNode || undefined
+  },
+  getFirstChild(node: TaroElement) {
+    return node.firstChild || undefined
+  },
+  getNextSibling(node: TaroElement) {
+    return node.nextSibling || undefined
+  },
+})
+
+export const render = renderer.render
+export const effect = renderer.effect
+export const memo = renderer.memo
+export const createComponent = (type, props) => {
+  if (typeof type === 'string') {
+    return h(type, props)
+  }
+  return renderer.createComponent(type, props)
+}
+export const createElement = renderer.createElement
+export const createTextNode = renderer.createTextNode
+export const insertNode = renderer.insertNode
+export const insert = renderer.insert
+export const spread = renderer.spread
+export const setProp = renderer.setProp
+export const mergeProps = renderer.mergeProps

package/dist/runtime-framework/solid/reconciler/use.ts

@@ -0,0 +1,8 @@
+import { createRenderEffect } from 'solid-js'
+
+export function use(fn, ele, accessor) {
+  createRenderEffect(() => {
+    fn(ele, accessor)
+  })
+}
+

package/dist/runtime-framework/solid/utils/index.ts

@@ -0,0 +1,49 @@
+import { Current } from '@tarojs/runtime'
+import { isArray } from '@tarojs/shared'
+
+export * from './is'
+
+export const noop = (..._: unknown[]) => {}
+
+export function capitalize (s: string) {
+  return s.charAt(0).toUpperCase() + s.slice(1)
+}
+
+export const incrementId = () => {
+  let n = 0
+  return () => (n++).toString()
+}
+
+export const EMPTY_OBJ: any = {}
+
+export const HOOKS_APP_ID = 'taro-app'
+
+export function ensureIsArray<T>(item: T | T[]): T[] {
+  if (isArray(item)) {
+    return item
+  } else {
+    return item ? [item] : []
+  }
+}
+
+/**
+ * set writable, enumerable to true
+ */
+export function setDefaultDescriptor(obj: Record<string, any>) {
+  obj.writable = true
+  obj.enumerable = true
+  return obj
+}
+
+/**
+ * 设置入口的路由参数
+ * @param options 小程序传入的参数
+ */
+export function setRouterParams(options) {
+  Current.router = {
+    params: options?.query,
+    ...options,
+  }
+}
+
+

package/dist/runtime-framework/solid/utils/is.ts

@@ -0,0 +1,46 @@
+export function isClassComponent (R, component) {
+  const prototype = component.prototype
+
+  // For React Redux
+  if (component.displayName?.includes('Connect')) return false
+
+  return (
+    isFunction(component.render) ||
+    !!prototype?.isReactComponent ||
+    prototype instanceof R.Component // compat for some others react-like library
+  )
+}
+
+export function isString (o: unknown): o is string {
+  return typeof o === 'string'
+}
+
+export function isUndefined (o: unknown): o is undefined {
+  return typeof o === 'undefined'
+}
+
+export function isNull (o: unknown): o is null {
+  return o === null
+}
+
+export function isObject<T> (o: unknown): o is T {
+  return o !== null && typeof o === 'object'
+}
+
+export function isBoolean (o: unknown): o is boolean {
+  return o === true || o === false
+}
+
+export function isFunction (o: unknown): o is (...args: any[]) => any {
+  return typeof o === 'function'
+}
+
+export function isNumber (o: unknown): o is number {
+  return typeof o === 'number'
+}
+
+export function isBooleanStringLiteral (o: unknown): o is string {
+  return o === 'true' || o === 'false'
+}
+
+export const isArray = Array.isArray