glass-easel 0.2.0 → 0.3.0

package/src/index.ts

@@ -1,102 +1,101 @@
 /* eslint-disable import/first */
 /* eslint-disable arrow-body-style */
 
-export { TextNode } from './text_node'
-export { NativeNode } from './native_node'
-export { ShadowRoot } from './shadow_root'
-export { VirtualNode } from './virtual_node'
 export {
-  globalOptions,
-  DeepCopyKind,
-  ComponentOptions,
-  EnvironmentOptions,
-  NormalizedComponentOptions,
-  getDefaultComponentSpace,
-} from './global_options'
-export { Element, StyleSegmentIndex } from './element'
-export * as dataUtils from './data_utils'
+  BackendMode,
+  GeneralBackendContext,
+  GeneralBackendElement,
+  backend,
+  composedBackend,
+  domlikeBackend,
+} from './backend'
+export { CurrentWindowBackendContext } from './backend/current_window_backend_context'
+export { EmptyBackendContext } from './backend/empty_backend'
+export { EmptyComposedBackendContext } from './backend/empty_composed_backend'
+export {
+  Behavior,
+  BehaviorBuilder,
+  BuilderContext,
+  GeneralBehavior,
+  GeneralBehaviorBuilder,
+} from './behavior'
+export { ClassList, StyleScopeId, StyleScopeManager } from './class_list'
+export {
+  Component,
+  ComponentDefinition,
+  GeneralComponent,
+  GeneralComponentDefinition,
+} from './component'
+export * as typeUtils from './component_params'
+export { ComponentSpace, getDefaultComponentSpace } from './component_space'
 export * as dataPath from './data_path'
 export {
+  DataChange,
   DataGroup,
-  GeneralDataGroup,
-  DataValue,
   DataObserver,
-  DataChange,
-  PropertyChange,
   DataUpdateCallback,
+  DataValue,
+  GeneralDataGroup,
+  NormalizedPropertyType,
+  PropertyChange,
 } from './data_proxy'
+export * as dataUtils from './data_utils'
+export { Element, StyleSegmentIndex } from './element'
+export { ElementIterator, ElementIteratorType } from './element_iterator'
 export {
   Event,
-  ShadowedEvent,
   EventBubbleStatus,
-  EventOptions,
   EventListener,
   EventListenerOptions,
   MutLevel as EventMutLevel,
+  EventOptions,
+  ShadowedEvent,
 } from './event'
-export * as typeUtils from './component_params'
-export {
-  Behavior,
-  GeneralBehavior,
-  BehaviorBuilder,
-  GeneralBehaviorBuilder,
-  BuilderContext,
-  NormalizedPropertyType,
-} from './behavior'
-export {
-  Component,
-  ComponentDefinition,
-  GeneralComponent,
-  GeneralComponentDefinition,
-} from './component'
-export { MutationObserver as Observer, MutationObserver } from './mutation_observer'
-export * as mutationObserver from './mutation_observer'
+export { ExternalShadowRoot } from './external_shadow_tree'
+export { FuncArr, GeneralFuncType, safeCallback } from './func_arr'
 export {
-  Node,
-  dumpElement,
-  dumpElementToString,
-  dumpSingleElementToString,
-  GeneralBackendElement,
-  GeneralBackendContext,
-  NodeCast,
-} from './node'
-export { ElementIterator, ElementIteratorType } from './element_iterator'
+  ComponentOptions,
+  DeepCopyKind,
+  EnvironmentOptions,
+  NormalizedComponentOptions,
+  globalOptions,
+} from './global_options'
+export { MutationObserver, MutationObserver as Observer } from './mutation_observer'
+export { NativeNode } from './native_node'
+export { Node, NodeCast, dumpElement, dumpElementToString, dumpSingleElementToString } from './node'
+export { RelationFailedListener, RelationListener, RelationType } from './relation'
+export { triggerRender } from './render'
+export { ParsedSelector } from './selector'
+export { ShadowRoot } from './shadow_root'
+export * as templateEngine from './template_engine'
+export { TextNode } from './text_node'
+export * as template from './tmpl'
+export { TraitBehavior } from './trait_behaviors'
+export { VirtualNode } from './virtual_node'
 export {
-  FuncArr,
-  GeneralFuncType,
-  safeCallback,
   addGlobalErrorListener,
-  removeGlobalErrorListener,
   addGlobalWarningListener,
+  removeGlobalErrorListener,
   removeGlobalWarningListener,
-} from './func_arr'
-export { ParsedSelector } from './selector'
-export { StyleScopeManager, ClassList, StyleScopeId } from './class_list'
-export { RelationType, RelationListener, RelationFailedListener } from './relation'
-export { TraitBehavior } from './trait_behaviors'
-export { triggerRender } from './render'
-export { ComponentSpace } from './component_space'
-export { ExternalShadowRoot } from './external_shadow_tree'
-export * as template from './tmpl'
-export * as backend from './backend/backend_protocol'
-export * as composedBackend from './backend/composed_backend_protocol'
-export * as domlikeBackend from './backend/domlike_backend_protocol'
-export { BackendMode } from './backend/mode'
-export * as templateEngine from './template_engine'
-export * as glassEaselTemplate from './tmpl'
+} from './warning'
 
+import { type Behavior } from './behavior'
+import {
+  Component,
+  type ComponentDefinition,
+  type GeneralComponent,
+  type GeneralComponentDefinition,
+} from './component'
 import {
-  ComponentParams,
-  DataList,
-  PropertyList,
-  MethodList,
-  ComponentInstance,
-  Empty,
+  type ComponentInstance,
+  type ComponentParams,
+  type DataList,
+  type Empty,
+  type MethodList,
+  type PropertyList,
 } from './component_params'
-import { Behavior } from './behavior'
-import { Component, ComponentDefinition, GeneralComponent, GeneralComponentDefinition } from './component'
+import { getDefaultComponentSpace } from './component_space'
 import { Event } from './event'
-import { getDefaultComponentSpace } from './global_options'
 
 export const registerBehavior = <
   TData extends DataList = Empty,

package/src/mutation_observer.ts

@@ -1,5 +1,8 @@
-import { Element, Node, TextNode } from '.'
+import { type Element } from './element'
 import { FuncArr } from './func_arr'
+import { type Node } from './node'
+import { type TextNode } from './text_node'
+import { isElement } from './type_symbol'
 
 /**
  * What the observer will listen
@@ -81,7 +84,7 @@ export class MutationObserverTarget {
     this._$subtreeObserversCount += diff
     const children = this._$boundElement.childNodes
     children.forEach((child) => {
-      if (child instanceof Element) {
+      if (isElement(child)) {
         if (!child._$mutationObserverTarget) {
           child._$mutationObserverTarget = new MutationObserverTarget(child)
         }
@@ -161,7 +164,7 @@ export class MutationObserver {
   /** Start observation */
   observe(
     targetElement: Element,
-    options: MutationObserverOptions = {
+    options: Partial<MutationObserverOptions> = {
       properties: false,
       childList: false,
       characterData: false,
@@ -190,7 +193,7 @@ export class MutationObserver {
     this._$normalizedListener = cb
     this._$boundTarget = target
     if (options.properties) {
-      if (!target.attrObservers) target.attrObservers = new FuncArr()
+      if (!target.attrObservers) target.attrObservers = new FuncArr('attributeObserver')
       target.attrObservers.add(cb)
       this._$boundFuncArrs.push(
         target.attrObservers as FuncArr<MutationObserverListener<MutationObserverEvent>>,
@@ -198,7 +201,7 @@ export class MutationObserver {
       this._$subtreeListenersCount += 1
     }
     if (options.childList) {
-      if (!target.childObservers) target.childObservers = new FuncArr()
+      if (!target.childObservers) target.childObservers = new FuncArr('childObserver')
       target.childObservers.add(cb)
       this._$boundFuncArrs.push(
         target.childObservers as FuncArr<MutationObserverListener<MutationObserverEvent>>,
@@ -206,7 +209,7 @@ export class MutationObserver {
       this._$subtreeListenersCount += 1
     }
     if (options.characterData) {
-      if (!target.textObservers) target.textObservers = new FuncArr()
+      if (!target.textObservers) target.textObservers = new FuncArr('textObserver')
       target.textObservers.add(cb)
       this._$boundFuncArrs.push(
         target.textObservers as FuncArr<MutationObserverListener<MutationObserverEvent>>,
@@ -217,7 +220,7 @@ export class MutationObserver {
       target.updateSubtreeCount(this._$subtreeListenersCount)
     }
     if (options.attachStatus) {
-      if (!target.attachObservers) target.attachObservers = new FuncArr()
+      if (!target.attachObservers) target.attachObservers = new FuncArr('attachObserver')
       target.attachObservers.add(cb)
       this._$boundFuncArrs.push(
         target.attachObservers as FuncArr<MutationObserverListener<MutationObserverEvent>>,

package/src/native_node.ts

@@ -1,71 +1,95 @@
-import * as backend from './backend/backend_protocol'
-import * as composedBackend from './backend/composed_backend_protocol'
-import * as domlikeBackend from './backend/domlike_backend_protocol'
-import { globalOptions } from './global_options'
-import { ClassList } from './class_list'
+import {
+  BM,
+  BackendMode,
+  type GeneralBackendElement,
+  type backend,
+  type composedBackend,
+  type domlikeBackend,
+} from './backend'
+import { ClassList, StyleScopeManager } from './class_list'
+import { type DataValue, type ModelBindingListener } from './data_proxy'
 import { Element } from './element'
-import { ShadowRoot } from './shadow_root'
-import { GeneralBackendElement } from '.'
-import { BM, BackendMode } from './backend/mode'
-import { DataValue, ModelBindingListener } from './data_proxy'
+import { ENV, globalOptions } from './global_options'
+import { performanceMeasureEnd, performanceMeasureStart } from './devtool'
+import { type ShadowRoot } from './shadow_root'
+import { NATIVE_NODE_SYMBOL, isNativeNode } from './type_symbol'
 
 export class NativeNode extends Element {
+  [NATIVE_NODE_SYMBOL]: true
   is: string
+  public stylingName: string
+  /* @internal */
   private _$modelBindingListeners?: { [name: string]: ModelBindingListener }
 
+  /* istanbul ignore next */
   constructor() {
     throw new Error('Element cannot be constructed directly')
     // eslint-disable-next-line no-unreachable
     super()
   }
 
+  static isNativeNode = isNativeNode
+
   static create(
     tagName: string,
     owner: ShadowRoot,
     stylingName?: string,
-    placeholderHandler?: () => void,
+    placeholderHandlerRemover?: () => void,
   ): NativeNode {
     const node = Object.create(NativeNode.prototype) as NativeNode
     node.is = tagName
-    node._$placeholderHandler = placeholderHandler
-    const nodeTreeContext = owner._$nodeTreeContext
-    let backendElement: GeneralBackendElement | null
-    if (BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike)) {
-      backendElement = (nodeTreeContext as domlikeBackend.Context).document.createElement(tagName)
-    } else if (BM.SHADOW || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Shadow)) {
-      const backend = owner._$backendShadowRoot
-      backendElement = backend?.createElement(tagName, stylingName ?? tagName) || null
-    } else {
-      const backend = nodeTreeContext as composedBackend.Context
-      backendElement = backend.createElement(tagName, stylingName ?? tagName)
+    node.stylingName = stylingName ?? tagName
+    node._$placeholderHandlerRemover = placeholderHandlerRemover
+    const nodeTreeContext = owner.getBackendContext()
+    let backendElement: GeneralBackendElement | null = null
+    if (nodeTreeContext) {
+      if (ENV.DEV) performanceMeasureStart('backend.createElement')
+      if (BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike)) {
+        backendElement = (nodeTreeContext as domlikeBackend.Context).document.createElement(tagName)
+      } else if (BM.SHADOW || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Shadow)) {
+        backendElement = owner._$backendShadowRoot!.createElement(tagName, node.stylingName)
+      } else {
+        const backend = nodeTreeContext as composedBackend.Context
+        backendElement = backend.createElement(tagName, node.stylingName)
+      }
+      if (ENV.DEV) performanceMeasureEnd()
     }
-    node._$initialize(false, backendElement, owner, nodeTreeContext)
-    node.classList = new ClassList(node, null)
-    if (owner && backendElement) {
-      const styleScope = owner.getHostNode()._$definition._$options.styleScope
-      if (styleScope) {
-        if (!(BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike))) {
-          ;(backendElement as backend.Element | composedBackend.Element).setStyleScope(styleScope)
-        }
+    node._$initialize(false, backendElement, owner, owner._$nodeTreeContext)
+    const ownerHost = owner.getHostNode()
+    const ownerComponentOptions = ownerHost.getComponentOptions()
+    const styleScope = ownerComponentOptions.styleScope ?? StyleScopeManager.globalScope()
+    const extraStyleScope = ownerComponentOptions.extraStyleScope ?? undefined
+    const styleScopeManager = ownerHost._$behavior.ownerSpace.styleScopeManager
+    node.classList = new ClassList(
+      node,
+      undefined,
+      ownerHost.classList,
+      styleScope,
+      extraStyleScope,
+      styleScopeManager,
+    )
+    if (backendElement) {
+      if (BM.COMPOSED || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Composed)) {
+        if (ENV.DEV) performanceMeasureStart('backend.setStyleScope')
+        ;(backendElement as composedBackend.Element).setStyleScope(styleScope, extraStyleScope)
+        if (ENV.DEV) performanceMeasureEnd()
       }
       if (globalOptions.writeExtraInfoToAttr) {
-        const prefix = owner
-          .getHostNode()
-          ._$behavior.ownerSpace?.styleScopeManager.queryName(styleScope)
+        const prefix = styleScopeManager.queryName(styleScope)
         if (prefix) {
           backendElement.setAttribute('exparser:info-class-prefix', `${prefix}--`)
         }
       }
-    }
-    if (backendElement) {
+      if (ENV.DEV) performanceMeasureStart('backend.associateValue')
       if (!(BM.DOMLIKE || (BM.DYNAMIC && owner.getBackendMode() === BackendMode.Domlike))) {
         ;(backendElement as backend.Element | composedBackend.Element).associateValue(node)
       } else {
-        ;(owner._$nodeTreeContext as domlikeBackend.Context).associateValue(
+        ;(owner.getBackendContext() as domlikeBackend.Context).associateValue(
           backendElement as domlikeBackend.Element,
           node,
         )
       }
+      if (ENV.DEV) performanceMeasureEnd()
     }
     return node
   }
@@ -83,6 +107,7 @@ export class NativeNode extends Element {
             listener.call(this, value)
           }
         }
+        if (ENV.DEV) performanceMeasureStart('backend.setModelBindingStat')
         if (BM.DOMLIKE || (BM.DYNAMIC && this.getBackendMode() === BackendMode.Domlike)) {
           ;(this.getBackendContext() as domlikeBackend.Context).setModelBindingStat(
             backendElement as domlikeBackend.Element,
@@ -95,8 +120,27 @@ export class NativeNode extends Element {
             listener,
           )
         }
+        if (ENV.DEV) performanceMeasureEnd()
       }
     }
     this._$modelBindingListeners[propName] = listener
   }
+
+  getModelBindingListeners() {
+    const listeners = Object.create(null) as { [name: string]: ModelBindingListener }
+    if (this._$modelBindingListeners) {
+      Object.keys(this._$modelBindingListeners).forEach((propName) => {
+        const listener = (value: DataValue) => {
+          const listener = this._$modelBindingListeners?.[propName]
+          if (listener) {
+            listener.call(this, value)
+          }
+        }
+        listeners[propName] = listener
+      })
+    }
+    return listeners
+  }
 }
+
+NativeNode.prototype[NATIVE_NODE_SYMBOL] = true

package/src/node.ts

@@ -1,22 +1,15 @@
-import * as backend from './backend/backend_protocol'
-import * as composedBackend from './backend/composed_backend_protocol'
-import * as domlikeBackend from './backend/domlike_backend_protocol'
-import { TextNode } from './text_node'
-import { Element } from './element'
-import { VirtualNode } from './virtual_node'
-import { Component, ComponentDefinition } from './component'
-import { NativeNode } from './native_node'
-import { DataList, PropertyList, MethodList, ComponentInstance } from './component_params'
-
-export type GeneralBackendContext =
-  | backend.Context
-  | composedBackend.Context
-  | domlikeBackend.Context
-
-export type GeneralBackendElement =
-  | backend.Element
-  | composedBackend.Element
-  | domlikeBackend.Element
+import { type ComponentDefinition } from './component'
+import {
+  type ComponentInstance,
+  type DataList,
+  type MethodList,
+  type PropertyList,
+} from './component_params'
+import { type Element } from './element'
+import { type NativeNode } from './native_node'
+import { type TextNode } from './text_node'
+import { isComponent, isElement, isNativeNode, isTextNode, isVirtualNode } from './type_symbol'
+import { type VirtualNode } from './virtual_node'
 
 export type Node = TextNode | Element
 
@@ -61,7 +54,7 @@ export interface NodeCast {
 
 const dumpAttributesToString = (elem: Element): string => {
   let ret = ''
-  if (elem instanceof Element) {
+  if (isElement(elem)) {
     if (elem._$slotName !== null) ret += ` (slot) name="${elem._$slotName}"`
     if (elem.id) ret += ` id="${elem.id}"`
     if (elem.slot) ret += ` slot="${elem.slot}"`
@@ -70,10 +63,10 @@ const dumpAttributesToString = (elem: Element): string => {
     const style = elem.style
     if (style) ret += ` style="${elem.style}"`
   }
-  if (elem instanceof VirtualNode) {
+  if (isVirtualNode(elem)) {
     // empty
-  } else if (elem instanceof Component) {
-    Component.listProperties(elem).forEach((propName) => {
+  } else if (isComponent(elem)) {
+    Object.keys(elem._$behavior._$propertyMap).forEach((propName) => {
       ret += ` ${propName}="${String((elem.data as DataList)[propName])}"`
     })
   } else {
@@ -85,20 +78,20 @@ const dumpAttributesToString = (elem: Element): string => {
 }
 
 export const dumpSingleElementToString = (elem: any) => {
-  if (elem instanceof Element) {
+  if (isElement(elem)) {
     let tagName: string
-    if (elem instanceof VirtualNode) {
+    if (isVirtualNode(elem)) {
       tagName = `(virtual):${elem.is}`
-    } else if (elem instanceof Component) {
+    } else if (isComponent(elem)) {
       tagName = `${elem.tagName}:${elem.is}`
-    } else if (elem instanceof NativeNode) {
+    } else if (isNativeNode(elem)) {
       tagName = elem.is
     } else {
       tagName = '(unknown)'
     }
     return `<${tagName}${dumpAttributesToString(elem)}>`
   }
-  if (elem instanceof TextNode) {
+  if (isTextNode(elem)) {
     return elem.textContent.trim()
   }
   if (elem === null) {
@@ -119,8 +112,8 @@ export const dumpElementToString = (elem: any, composed: boolean, tabDepth = 0)
   let ret = linePrefix + dumpSingleElementToString(elem)
   let isExternal = false
 
-  if (elem instanceof Element) {
-    if (elem instanceof Component) {
+  if (isElement(elem)) {
+    if (isComponent(elem)) {
       isExternal = elem._$external
     }
     if (composed) {

package/src/relation.ts

@@ -1,9 +1,12 @@
-import { VirtualNode } from './virtual_node'
-import { GeneralBehavior } from './behavior'
-import { Component, GeneralComponent } from './component'
-import { Element } from './element'
-import { safeCallback, triggerWarning } from './func_arr'
+import { Behavior, type GeneralBehavior } from './behavior'
+import { ComponentDefinition, type GeneralComponent } from './component'
+import { type RelationParams, type TraitRelationParams } from './component_params'
+import { type ComponentSpace } from './component_space'
+import { type Element } from './element'
+import { safeCallback } from './func_arr'
 import { TraitBehavior } from './trait_behaviors'
+import { isComponent, isElement, isVirtualNode } from './type_symbol'
+import { triggerWarning } from './warning'
 
 export const enum RelationType {
   Ancestor = 0,
@@ -16,6 +19,92 @@ export const enum RelationType {
 
 const RELATION_TYPE_COUNT = 6
 
+export const normalizeRelation = <TOut extends { [key: string]: any }>(
+  ownerSpace: ComponentSpace,
+  is: string,
+  key: string,
+  relation: RelationParams | TraitRelationParams<TOut>,
+): RelationDefinition | null => {
+  const checkRelationFunc = (f: unknown): RelationListener | null => {
+    if (typeof f === 'function') {
+      return f as RelationListener
+    }
+    if (f !== undefined) {
+      triggerWarning(
+        `the "${key}" relation listener is not a function (when preparing behavior "${is}").`,
+      )
+    }
+    return null
+  }
+  let type: RelationType
+  if (relation.type === 'parent') {
+    type = RelationType.ParentComponent
+  } else if (relation.type === 'child') {
+    type = RelationType.ChildComponent
+  } else if (relation.type === 'parent-common-node') {
+    type = RelationType.ParentNonVirtualNode
+  } else if (relation.type === 'child-common-node') {
+    type = RelationType.ChildNonVirtualNode
+  } else if (relation.type === 'ancestor') {
+    type = RelationType.Ancestor
+  } else if (relation.type === 'descendant') {
+    type = RelationType.Descendant
+  } else {
+    const type = relation.type as string
+    triggerWarning(
+      `the "${key}" relation has an invalid relation type "${type}" (when preparing behavior "${is}").`,
+    )
+    return null
+  }
+  let target:
+    | GeneralBehavior
+    | TraitBehavior<{ [key: string]: unknown }, { [key: string]: unknown }>
+    | null = null
+  if (relation.target instanceof ComponentDefinition) {
+    target = relation.target.behavior as GeneralBehavior
+  } else if (relation.target instanceof Behavior || relation.target instanceof TraitBehavior) {
+    target = relation.target
+  } else {
+    const path = String(relation.target || key)
+    const usingTarget = ownerSpace.getComponentByUrlWithoutDefault(path, is)
+    if (usingTarget) {
+      target = usingTarget.behavior
+    } else {
+      const globalTarget = ownerSpace.getGlobalUsingComponent(path)
+      if (typeof globalTarget === 'object' && globalTarget !== null) {
+        target = globalTarget.behavior
+      }
+    }
+  }
+  if (!target) {
+    triggerWarning(
+      `the target of relation "${key}" is not a valid behavior or component (when preparing behavior "${is}").`,
+    )
+    return null
+  }
+  return {
+    target,
+    type,
+    linked: checkRelationFunc(relation.linked),
+    linkChanged: checkRelationFunc(relation.linkChanged),
+    unlinked: checkRelationFunc(relation.unlinked),
+    linkFailed: checkRelationFunc(relation.linkFailed) as RelationFailedListener,
+  }
+}
+
+export interface RelationHandler<TTarget, TOut> {
+  list(): TTarget[]
+  listAsTrait: TOut extends never ? undefined : () => TOut[]
+}
+
+export interface RelationInit {
+  (def: RelationParams): RelationHandler<any, never>
+  <TOut extends { [key: string]: any }>(def: TraitRelationParams<TOut>): RelationHandler<
+    unknown,
+    TOut
+  >
+}
+
 export type RelationListener = (target: unknown) => void
 
 export type RelationFailedListener = () => void
@@ -165,10 +254,10 @@ export class Relation {
           const next = cur.parentNode
           if (!next) break
           cur = next
-          if (cur instanceof VirtualNode) {
+          if (isVirtualNode(cur)) {
             continue
           }
-          if (cur instanceof Component) {
+          if (isComponent(cur)) {
             if (cur.hasBehavior(parentBehavior)) {
               const parentRelation = cur._$relation
               if (parentRelation) {
@@ -186,7 +275,7 @@ export class Relation {
                     const def = parentDefs[j]!
                     if (def.target && this._$comp.hasBehavior(def.target)) {
                       newLink = {
-                        target: cur as GeneralComponent,
+                        target: cur,
                         def,
                       }
                       break
@@ -304,12 +393,12 @@ export class Relation {
       const children = node.childNodes
       for (let i = 0; i < children.length; i += 1) {
         const child = children[i]!
-        if (!(child instanceof Element)) continue
-        if (child instanceof VirtualNode) {
+        if (!isElement(child)) continue
+        if (isVirtualNode(child)) {
           dfs(child)
           continue
         }
-        if (child instanceof Component) {
+        if (isComponent(child)) {
           if (child._$relation) {
             let links
             if (type === RelationType.ChildComponent) {
@@ -323,7 +412,7 @@ export class Relation {
               for (let i = 0; i < links.length; i += 1) {
                 const link = links[i]!
                 if (link && link.target === comp && link.def === def) {
-                  ret.push(child as GeneralComponent)
+                  ret.push(child)
                   break
                 }
               }

package/src/render.ts

@@ -1,6 +1,6 @@
+import { type GeneralBackendContext } from './backend'
+import { type Element } from './element'
 import { safeCallback } from './func_arr'
-import { Element } from './element'
-import { GeneralBackendContext } from './node'
 
 const triggerRenderOnContext = (
   context: GeneralBackendContext,
@@ -15,5 +15,7 @@ const triggerRenderOnContext = (
 
 export const triggerRender = (element: Element, callback?: (err: Error | null) => void) => {
   const context = element.getBackendContext()
-  triggerRenderOnContext(context, callback || null)
+  if (context) {
+    triggerRenderOnContext(context, callback || null)
+  }
 }