glass-easel-miniprogram-adapter 0.2.0 → 0.3.0

package/src/behavior.ts

@@ -1,5 +1,6 @@
-import * as glassEasel from 'glass-easel'
-import { GeneralComponentDefinition, utils as typeUtils } from './types'
+import type * as glassEasel from 'glass-easel'
+import { type GeneralComponentDefinition, type utils as typeUtils } from './types'
+import { type GeneralComponent } from './component'
 
 type DataList = typeUtils.DataList
 type PropertyList = typeUtils.PropertyList
@@ -23,19 +24,24 @@ export class Behavior<
   TProperty extends PropertyList,
   TMethod extends MethodList,
   TChainingFilter extends ChainingFilterType,
+  TComponentExport = never,
 > {
   /** @internal */
   _$: glassEasel.GeneralBehavior
   /** @internal */
   _$bindedDefinitionFilter?: (target: GeneralComponentDefinition) => void
+  /** @internal */
+  _$export?: (source: GeneralComponent | null) => TComponentExport
 
   /** @internal */
   constructor(
     inner: glassEasel.Behavior<TData, TProperty, TMethod, TChainingFilter>,
     parents: GeneralBehavior[],
     definitionFilter: DefinitionFilter | undefined,
+    componentExport: ((source: GeneralComponent | null) => TComponentExport) | undefined,
   ) {
     this._$ = inner as glassEasel.GeneralBehavior
+    this._$export = componentExport
 
     // processing definition filter
     if (definitionFilter !== undefined) {

package/src/builder/base_behavior_builder.ts

@@ -0,0 +1,437 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+import * as glassEasel from 'glass-easel'
+import { Behavior, ComponentType, TraitBehavior } from '../behavior'
+import type { BehaviorDefinition, utils as typeUtils } from '../types'
+import type { GeneralBehavior } from '../behavior'
+import type { AllData, Component, GeneralComponent } from '../component'
+import type { CodeSpace } from '../space'
+import type {
+  ResolveBehaviorBuilder,
+  Lifetimes,
+  RelationParams,
+  TraitRelationParams,
+  BuilderContext,
+} from './type_utils'
+
+type Empty = typeUtils.Empty
+type DataList = typeUtils.DataList
+type PropertyList = typeUtils.PropertyList
+type PropertyType = typeUtils.PropertyType
+type PropertyTypeToValueType<T extends PropertyType> = typeUtils.PropertyTypeToValueType<T>
+type MethodList = typeUtils.MethodList
+type ChainingFilterType = typeUtils.ChainingFilterType
+type ComponentMethod = typeUtils.ComponentMethod
+type TaggedMethod<Fn extends ComponentMethod> = typeUtils.TaggedMethod<Fn>
+
+export class BaseBehaviorBuilder<
+  TPrevData extends DataList = Empty,
+  TData extends DataList = Empty,
+  TProperty extends PropertyList = Empty,
+  TMethod extends MethodList = Empty,
+  TChainingFilter extends ChainingFilterType = never,
+  TPendingChainingFilter extends ChainingFilterType = never,
+  TComponentExport = never,
+> {
+  protected _$codeSpace!: CodeSpace
+  protected _$!: glassEasel.BehaviorBuilder<
+    TPrevData,
+    TData,
+    TProperty,
+    TMethod,
+    TChainingFilter,
+    TPendingChainingFilter
+  >
+  protected _$parents: GeneralBehavior[] = []
+  protected _$export?: (source: GeneralComponent | null) => TComponentExport
+
+  /** Implement a trait behavior */
+  implement<TIn extends { [key: string]: any }>(
+    traitBehavior: TraitBehavior<TIn, any>,
+    impl: TIn,
+  ): ResolveBehaviorBuilder<this, TChainingFilter> {
+    this._$.implement(traitBehavior._$, impl)
+    return this as any
+  }
+
+  /** Add external classes */
+  externalClasses(list: string[]): this {
+    this._$.externalClasses(list)
+    return this
+  }
+
+  /** Set the export value when the component is being selected */
+  export<TNewComponentExport>(
+    f: (this: GeneralComponent, source: GeneralComponent | null) => TNewComponentExport,
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      TPrevData,
+      TData,
+      TProperty,
+      TMethod,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TNewComponentExport
+    >,
+    TChainingFilter
+  > {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    this._$export = f as any
+    return this as any
+  }
+
+  data<T extends DataList>(
+    gen: () => typeUtils.NewFieldList<AllData<TData, TProperty>, T>,
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      T,
+      TData & T,
+      TProperty,
+      TMethod,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TComponentExport
+    >,
+    TChainingFilter
+  > {
+    this._$.data(gen)
+    return this as any
+  }
+
+  property<N extends string, T extends PropertyType, V extends PropertyTypeToValueType<T>>(
+    name: N,
+    def: N extends keyof (TData & TProperty) ? never : typeUtils.PropertyListItem<T, V>,
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      TPrevData,
+      TData,
+      TProperty & Record<N, unknown extends V ? T : typeUtils.PropertyOption<T, V>>,
+      TMethod,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TComponentExport
+    >,
+    TChainingFilter
+  > {
+    this._$.property(name, def)
+    return this as any
+  }
+
+  /**
+   * Add some public methods
+   *
+   * The public method can be used as an event handler, and can be visited in component instance.
+   */
+  methods<T extends MethodList>(
+    funcs: T & ThisType<Component<TData, TProperty, TMethod & T, any>>,
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      TPrevData,
+      TData,
+      TProperty,
+      TMethod & T,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TComponentExport
+    >,
+    TChainingFilter
+  > {
+    this._$.methods(funcs)
+    return this as any
+  }
+
+  /**
+   * Add a data observer
+   */
+  observer<
+    P extends typeUtils.ObserverDataPathStrings<
+      typeUtils.DataWithPropertyValues<TPrevData, TProperty>
+    >,
+    V = typeUtils.GetFromObserverPathString<
+      typeUtils.DataWithPropertyValues<TPrevData, TProperty>,
+      P
+    >,
+  >(
+    paths: P,
+    func: (this: Component<TData, TProperty, TMethod, any>, newValue: V) => void,
+    once?: boolean,
+  ): ResolveBehaviorBuilder<this, TChainingFilter>
+  observer<
+    P extends typeUtils.ObserverDataPathStrings<
+      typeUtils.DataWithPropertyValues<TPrevData, TProperty>
+    >[],
+    V = {
+      [K in keyof P]: typeUtils.GetFromObserverPathString<
+        typeUtils.DataWithPropertyValues<TPrevData, TProperty>,
+        P[K]
+      >
+    },
+  >(
+    paths: readonly [...P],
+    func: (
+      this: Component<TData, TProperty, TMethod, any>,
+      ...newValues: V extends any[] ? V : never
+    ) => void,
+    once?: boolean,
+  ): ResolveBehaviorBuilder<this, TChainingFilter>
+  observer(
+    paths: string | readonly string[],
+    func: (this: Component<TData, TProperty, TMethod, any>, ...args: any[]) => any,
+    once = false,
+  ): ResolveBehaviorBuilder<this, TChainingFilter> {
+    this._$.observer(paths as any, func as any, once)
+    return this as any
+  }
+
+  /**
+   * Add a lifetime callback
+   */
+  lifetime<L extends keyof Lifetimes>(
+    name: L,
+    func: (
+      this: Component<TData, TProperty, TMethod, any>,
+      ...args: Parameters<Lifetimes[L]>
+    ) => ReturnType<Lifetimes[L]>,
+    once = false,
+  ): ResolveBehaviorBuilder<this, TChainingFilter> {
+    this._$.lifetime(name, func as any, once)
+    return this as any
+  }
+
+  /**
+   * Add a page-lifetime callback
+   */
+  pageLifetime(
+    name: string,
+    func: (this: Component<TData, TProperty, TMethod, any>, ...args: any[]) => any,
+    once = false,
+  ): ResolveBehaviorBuilder<this, TChainingFilter> {
+    this._$.pageLifetime(name, func as any, once)
+    return this as any
+  }
+
+  /**
+   * Add a relation
+   */
+  relation(
+    name: string,
+    rel: RelationParams & ThisType<Component<TData, TProperty, TMethod, TComponentExport>>,
+  ): ResolveBehaviorBuilder<this, TChainingFilter> {
+    const target =
+      rel.target instanceof Behavior || rel.target instanceof ComponentType
+        ? rel.target._$
+        : rel.target
+    this._$.relation(name, {
+      target,
+      type: rel.type,
+      linked: rel.linked,
+      linkChanged: rel.linkChanged,
+      unlinked: rel.unlinked,
+      linkFailed: rel.linkFailed,
+    } as any)
+    return this as any
+  }
+
+  init<TExport extends Record<string, TaggedMethod<(...args: any[]) => any>> | void>(
+    func: (
+      this: Component<TData, TProperty, TMethod, TComponentExport>,
+      builderContext: BuilderContext<
+        TPrevData,
+        TProperty,
+        Component<TData, TProperty, TMethod, TComponentExport>
+      >,
+    ) => TExport,
+    // eslint-disable-next-line function-paren-newline
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      TPrevData,
+      TData,
+      TProperty,
+      TMethod,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TComponentExport
+    >,
+    TChainingFilter
+  > {
+    this._$.init(function ({
+      data,
+      setData,
+      implement,
+      relation,
+      observer,
+      lifetime,
+      pageLifetime,
+      method,
+      listener,
+    }) {
+      const relationInit = ((rel: RelationParams | TraitRelationParams<any>) => {
+        if (rel.target instanceof TraitBehavior) {
+          return relation({
+            target: rel.target._$,
+            type: rel.type,
+            linked: rel.linked,
+            linkChanged: rel.linkChanged,
+            unlinked: rel.unlinked,
+            linkFailed: rel.linkFailed,
+          } as any)
+        }
+        const target =
+          rel.target instanceof Behavior || rel.target instanceof ComponentType
+            ? rel.target._$
+            : rel.target
+        return relation({
+          target,
+          type: rel.type,
+          linked: rel.linked,
+          linkChanged: rel.linkChanged,
+          unlinked: rel.unlinked,
+          linkFailed: rel.linkFailed,
+        } as any)
+      }) as BuilderContext<TPrevData, TProperty, TMethod>['relation']
+
+      const implementInit = ((traitBehavior: TraitBehavior<any>, impl: Record<string, any>) => {
+        implement(traitBehavior._$, impl)
+      }) as BuilderContext<TPrevData, TProperty, TMethod>['implement']
+
+      const methodCaller = this as unknown as Component<TData, TProperty, TMethod, TComponentExport>
+
+      return func.call(methodCaller, {
+        self: methodCaller,
+        data,
+        setData: (newData, callback) => {
+          setData(newData)
+          if (callback) {
+            glassEasel.triggerRender(methodCaller._$, () => {
+              callback()
+            })
+          }
+        },
+        implement: implementInit,
+        relation: relationInit,
+        observer,
+        lifetime,
+        pageLifetime,
+        method,
+        listener,
+      })
+    })
+    return this as any
+  }
+
+  definition<
+    TNewData extends DataList = Empty,
+    TNewProperty extends PropertyList = Empty,
+    TNewMethod extends MethodList = Empty,
+    TNewComponentExport = never,
+  >(
+    def: BehaviorDefinition<TNewData, TNewProperty, TNewMethod, TNewComponentExport> &
+      ThisType<
+        Component<
+          TData & TNewData,
+          TProperty & TNewProperty,
+          TMethod & TNewMethod,
+          TNewComponentExport
+        >
+      >,
+  ): ResolveBehaviorBuilder<
+    BaseBehaviorBuilder<
+      TPrevData,
+      TData & TNewData,
+      TProperty & TNewProperty,
+      TMethod & TNewMethod,
+      TChainingFilter,
+      TPendingChainingFilter,
+      TNewComponentExport
+    >,
+    TChainingFilter
+  > {
+    def.behaviors?.forEach((beh) => beh._$bindedDefinitionFilter?.(def))
+    const inner = this._$
+    const {
+      behaviors,
+      properties: rawProperties,
+      data: rawData,
+      observers: rawObservers,
+      methods,
+      created,
+      attached,
+      ready,
+      moved,
+      detached,
+      lifetimes: rawLifetimes,
+      pageLifetimes: rawPageLifetimes,
+      relations: rawRelations,
+      externalClasses,
+      export: exports,
+    } = def
+    behaviors?.forEach((beh) => {
+      this._$parents.push(beh as GeneralBehavior)
+      inner.behavior(beh._$)
+    })
+    if (rawData !== undefined) {
+      if (typeof rawData === 'function') {
+        inner.data(rawData as any)
+      } else {
+        inner.staticData(rawData as any)
+      }
+    }
+    if (rawProperties !== undefined) {
+      const keys = Object.keys(rawProperties)
+      for (let i = 0; i < keys.length; i += 1) {
+        const name = keys[i]!
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        inner.property(name, rawProperties[name] as any)
+      }
+    }
+    if (rawObservers !== undefined) {
+      if (Array.isArray(rawObservers)) {
+        for (let i = 0; i < rawObservers.length; i += 1) {
+          const { fields, observer } = rawObservers[i]!
+          inner.observer(fields || ('**' as any), observer)
+        }
+      } else {
+        const keys = Object.keys(rawObservers)
+        for (let i = 0; i < keys.length; i += 1) {
+          const fields = keys[i]!
+          const observer = rawObservers[fields]!
+          inner.observer(fields as any, observer)
+        }
+      }
+    }
+    if (methods) inner.methods(methods)
+    if (created && rawLifetimes?.created === undefined) inner.lifetime('created', created, true)
+    if (attached && rawLifetimes?.attached === undefined) inner.lifetime('attached', attached, true)
+    if (ready && rawLifetimes?.ready === undefined) inner.lifetime('ready', ready, true)
+    if (moved && rawLifetimes?.moved === undefined) inner.lifetime('moved', moved, true)
+    if (detached && rawLifetimes?.detached === undefined) inner.lifetime('detached', detached, true)
+    if (rawLifetimes) {
+      const keys = Object.keys(rawLifetimes)
+      for (let i = 0; i < keys.length; i += 1) {
+        const name = keys[i]!
+        const func = rawLifetimes[name]!
+        inner.lifetime(name as any, func, true)
+      }
+    }
+    if (rawPageLifetimes) {
+      const keys = Object.keys(rawPageLifetimes)
+      for (let i = 0; i < keys.length; i += 1) {
+        const name = keys[i]!
+        const func = rawPageLifetimes[name]!
+        inner.pageLifetime(name, func, true)
+      }
+    }
+    if (rawRelations) {
+      const keys = Object.keys(rawRelations)
+      for (let i = 0; i < keys.length; i += 1) {
+        const name = keys[i]!
+        const rel = rawRelations[name]!
+        inner.relation(name, rel)
+      }
+    }
+    if (externalClasses) inner.externalClasses(externalClasses)
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    if (exports) this._$export = exports as any
+    return this as any
+  }
+}