glass-easel 0.2.0 → 0.3.0

package/src/virtual_node.ts

@@ -1,39 +1,52 @@
+import { BM, BackendMode, type GeneralBackendContext } from './backend'
+import { performanceMeasureEnd, performanceMeasureStart } from './devtool'
 import { Element } from './element'
-import { ShadowRoot } from './shadow_root'
-import { BM, BackendMode } from './backend/mode'
-import { GeneralBackendContext, GeneralBackendElement } from './node'
-import * as backend from './backend/backend_protocol'
+import { ENV } from './global_options'
+import { type ShadowRoot } from './shadow_root'
+import { VIRTUAL_NODE_SYMBOL, isVirtualNode } from './type_symbol'
 
 export class VirtualNode extends Element {
+  [VIRTUAL_NODE_SYMBOL]: true
   is: string
 
+  /* istanbul ignore next */
   constructor() {
     throw new Error('Element cannot be constructed directly')
     // eslint-disable-next-line no-unreachable
     super()
   }
 
+  /* @internal */
   protected _$initializeVirtual(
     virtualName: string,
     owner: ShadowRoot,
-    nodeTreeContext: GeneralBackendContext,
-    backendElement: GeneralBackendElement | null,
+    nodeTreeContext: GeneralBackendContext | null,
   ) {
     this.is = String(virtualName)
-    if (BM.SHADOW || (BM.DYNAMIC && nodeTreeContext.mode === BackendMode.Shadow)) {
-      const shadowRoot = owner._$backendShadowRoot
-      const be =
-        (backendElement as backend.Element) || shadowRoot?.createVirtualNode(virtualName) || null
+    if (
+      nodeTreeContext &&
+      (BM.SHADOW || (BM.DYNAMIC && nodeTreeContext.mode === BackendMode.Shadow))
+    ) {
+      const shadowRoot = owner._$backendShadowRoot!
+      if (ENV.DEV) performanceMeasureStart('backend.createVirtualNode')
+      const be = shadowRoot.createVirtualNode(virtualName)
+      if (ENV.DEV) performanceMeasureEnd()
       this._$initialize(true, be, owner, nodeTreeContext)
-      be?.associateValue(this)
+      if (ENV.DEV) performanceMeasureStart('backend.associateValue')
+      be.associateValue(this)
+      if (ENV.DEV) performanceMeasureEnd()
     } else {
-      this._$initialize(true, backendElement, owner, nodeTreeContext)
+      this._$initialize(true, null, owner, owner._$nodeTreeContext)
     }
   }
 
+  static isVirtualNode = isVirtualNode
+
   static create(virtualName: string, owner: ShadowRoot): VirtualNode {
     const node = Object.create(VirtualNode.prototype) as VirtualNode
-    node._$initializeVirtual(virtualName, owner, owner._$nodeTreeContext, null)
+    node._$initializeVirtual(virtualName, owner, owner.getBackendContext())
     return node
   }
 }
+
+VirtualNode.prototype[VIRTUAL_NODE_SYMBOL] = true

package/src/warning.ts

@@ -0,0 +1,119 @@
+import { type AnyComponent, type GeneralComponent } from './component'
+import { FuncArr, _setErrorDispatcher } from './func_arr'
+import { globalOptions } from './global_options'
+import { type Node, dumpSingleElementToString } from './node'
+import { isComponent } from './type_symbol'
+
+let insideErrorHandler = false
+
+const errorFuncArr = new FuncArr<ErrorListener>('error')
+const warningFuncArr = new FuncArr<WarningListener>('warning')
+
+_setErrorDispatcher(dispatchError)
+
+export type ErrorListener = (
+  error: unknown,
+  method?: string,
+  relatedComponent?: GeneralComponent | string,
+  element?: Node,
+) => boolean | void
+
+export type WarningListener = (
+  message: string,
+  relatedComponent: GeneralComponent | string,
+  element?: Node,
+) => boolean | void
+
+export function dispatchError(
+  err: unknown,
+  method?: string,
+  relatedComponent?: AnyComponent | string,
+  element?: Node,
+) {
+  if (!insideErrorHandler) {
+    insideErrorHandler = true
+    if (isComponent(relatedComponent)) {
+      relatedComponent.triggerLifetime('error', [err])
+    }
+    const shouldBreak =
+      errorFuncArr.call(err as any, [err, method, relatedComponent, element]) === false
+    insideErrorHandler = false
+    if (shouldBreak) return
+  }
+  if (globalOptions.throwGlobalError) {
+    throw err
+  } else {
+    // eslint-disable-next-line no-console
+    console.error(
+      [
+        err instanceof Error ? `${err.message}` : String(err),
+        element ? `\t@${dumpSingleElementToString(element)}` : undefined,
+        relatedComponent
+          ? `\t${method || ''}@${
+              typeof relatedComponent === 'string'
+                ? `<${relatedComponent}>`
+                : dumpSingleElementToString(relatedComponent || false)
+            }`
+          : undefined,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    )
+  }
+}
+
+export function triggerWarning(
+  msg: string,
+  relatedComponent?: AnyComponent | string,
+  element?: Node,
+) {
+  if (warningFuncArr.call(null, [msg, relatedComponent || '', element])) {
+    // eslint-disable-next-line no-console
+    console.warn(msg)
+  }
+}
+
+export class ThirdError extends Error {
+  constructor(
+    message: string,
+    public additionalStack?: string,
+    public relatedComponent?: AnyComponent | string,
+    public element?: Node,
+  ) {
+    super(message)
+    dispatchError(this, additionalStack, relatedComponent, element)
+  }
+}
+
+export function addGlobalErrorListener(func: ErrorListener) {
+  errorFuncArr.add(func)
+}
+
+export function removeGlobalErrorListener(func: ErrorListener) {
+  errorFuncArr.remove(func)
+}
+
+export function addGlobalWarningListener(func: WarningListener) {
+  warningFuncArr.add(func)
+}
+
+export function removeGlobalWarningListener(func: WarningListener) {
+  warningFuncArr.remove(func)
+}
+
+export function safeCallback<F extends (this: any, ...args: any[]) => any>(
+  this: void,
+  type: string,
+  method: F,
+  caller: ThisParameterType<F>,
+  args: Parameters<F>,
+  relatedComponent?: AnyComponent,
+): ReturnType<F> | undefined {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    return method.apply(caller, args)
+  } catch (e) {
+    dispatchError(e, `${type || 'Listener'} ${method.name || '(anonymous)'}`, relatedComponent)
+    return undefined
+  }
+}