@oinone/kunlun-vue-widget 6.2.0

package/dist/types/src/hooks/all-mounted.d.ts

@@ -0,0 +1,20 @@
+declare type onAllMountedFn = () => void;
+declare type onAllMountedOptions = {
+    allMounted?: () => void;
+    allMountedUpdate?: () => void;
+};
+/**
+ * 在子组件全部挂载时执行（需配合{@link reportAllMounted}使用）
+ * @param fn 全部挂载时执行函数; allMounted仅会调用一次，allMountedUpdate会重复调用;
+ */
+export declare function onAllMounted(fn: onAllMountedFn | onAllMountedOptions): void;
+/**
+ * 子组件上报挂载状态，用于执行{@link onAllMounted}传入的全部挂载时执行函数，该方法会防止提供者方法向下透传，如需进行连续处理，应先使用reportAllMounted，再使用onAllMounted方法
+ * @param options
+ */
+export declare function reportAllMounted(options?: {
+    onBeforeMount?: () => void | Promise<void>;
+    onMounted?: () => void | Promise<void>;
+    onUnmounted?: () => void | Promise<void>;
+}): void;
+export {};

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './all-mounted';

package/dist/types/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './basic';
+export * from './data';
+export * from './dsl';
+export * from './feature';
+export * from './hooks';
+export * from './token';
+export * from './typing';
+export * from './util';
+export * from './view';

package/dist/types/src/token/index.d.ts

@@ -0,0 +1,2 @@
+import { InjectionKey } from 'vue';
+export declare const genToken: <T>(name: string) => InjectionKey<T>;

package/dist/types/src/typing/WidgetTagContext.d.ts

@@ -0,0 +1,39 @@
+import { DslDefinition } from '@oinone/kunlun-dsl';
+import { Slots } from 'vue';
+import { VueWidget } from '../basic';
+import { DslDefinitionWidgetProps } from '../dsl';
+/**
+ * 渲染组件
+ */
+export interface RenderWidget {
+    /**
+     * 当前组件唯一键
+     */
+    handle: string;
+    /**
+     * 主要组件
+     */
+    widget: VueWidget;
+    /**
+     * 混入组件
+     */
+    widgets: VueWidget[];
+}
+/**
+ * 组件标签上下文
+ */
+export interface WidgetTagContext extends Record<string, unknown> {
+    dslDefinition: DslDefinition;
+    slotName: string;
+    widgetHandle: string;
+    widget: VueWidget;
+    widgets: VueWidget[];
+    slotContext?: Record<string, unknown>;
+    getWidgetTag(): string;
+    getParentHandle(): string;
+    getDslDefinition(): DslDefinition | undefined;
+    getSlotName(): string;
+    getProps(): DslDefinitionWidgetProps;
+    getCurrentSlots(): Slots | undefined;
+    createWidget(slots?: Slots): RenderWidget | undefined;
+}

package/dist/types/src/typing/WidgetTagProps.d.ts

@@ -0,0 +1,23 @@
+import { DslDefinition } from '@oinone/kunlun-dsl';
+import { PropType } from 'vue';
+/**
+ * 组件标签属性
+ */
+export declare const WidgetTagProps: {
+    handle: {
+        type: StringConstructor;
+    };
+    dslDefinition: {
+        type: PropType<DslDefinition>;
+    };
+    slotName: {
+        type: StringConstructor;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    slotContext: {
+        type: ObjectConstructor;
+    };
+};

package/dist/types/src/typing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './WidgetTagProps';
+export * from './WidgetTagContext';
+export * from './typing';

package/dist/types/src/typing/typing.d.ts

@@ -0,0 +1,7 @@
+export declare enum InnerWidgetType {
+    Action = "Action",
+    Field = "Field",
+    Element = "Element",
+    View = "View",
+    Mask = "Mask"
+}

package/dist/types/src/util/dsl-render.d.ts

@@ -0,0 +1,106 @@
+import { DslDefinition, DslSlots } from '@oinone/kunlun-dsl';
+import { Component, Slots, VNode } from 'vue';
+export declare const DEFAULT_TAG_PREFIX = "oinone";
+export declare const SLOTS_KEY = "__slots";
+export declare const RENDER_OPTIONS_KEY = "__render__options";
+export declare const SLOT_CONTEXT_KEY = "slotContext";
+/**
+ * 渲染可选项
+ */
+export interface DslRenderOptions {
+    /**
+     * 动态key
+     * 当key不存在时进行自动生成
+     */
+    dynamicKey?: boolean;
+    /**
+     * 是否强制更新
+     * 永远使用新的key进行渲染
+     */
+    focusUpdate?: boolean;
+    /**
+     * 是否递归渲染
+     * 递归渲染有性能损耗，但可以解决某些渲染问题，建议在明确递归层数的情况下局部使用该参数
+     */
+    recursion?: boolean;
+    /**
+     * vue createVNode patchFlag
+     */
+    patchFlag?: number;
+    /**
+     * vue createVNode dynamicProps
+     */
+    dynamicProps?: string[] | null;
+    /**
+     * vue createVNode isBlockNode
+     */
+    isBlockNode?: boolean;
+    /**
+     * 插槽上下文
+     */
+    slotContext?: Record<string, unknown>;
+}
+export declare type DslChildren = string | VNode[] | Slots;
+/**
+ * dsl扩展属性
+ */
+export declare type DslRenderExtendProp = {
+    __slots?: DslChildren;
+    __render__options?: DslRenderOptions;
+};
+export declare type DslRenderDefinition = DslDefinition & DslRenderExtendProp;
+export declare type DslPropType = {
+    dslDefinition: DslRenderDefinition;
+    slotName: string;
+    slotContext?: Record<string, unknown>;
+    [key: string]: any;
+} & DslRenderExtendProp;
+declare type ResolveComponentType = Component | string;
+/**
+ * dsl渲染
+ */
+export declare class DslRender {
+    private static resolveComponentCache;
+    private static resolveCommonComponentCache;
+    /**
+     * 渲染指定dsl定义到对应插槽
+     * @param dsl 指定dsl
+     * @param slotName 插槽名称 默认为: default
+     * @param children 插槽
+     * @param options 渲染可选项
+     */
+    static render(dsl: DslRenderDefinition, slotName?: string, children?: DslChildren, options?: DslRenderOptions): VNode | undefined;
+    /**
+     * 渲染dsl插槽
+     * @param dslSlots dsl插槽
+     */
+    static renderSlots(dslSlots: DslSlots): Slots;
+    /**
+     * 通过指定dsl获取VNode插槽
+     * @param dsl 指定dsl
+     * @param supportedSlotNames
+     */
+    static fetchVNodeSlots(dsl: DslDefinition | undefined, supportedSlotNames?: string[]): Slots | undefined;
+    /**
+     * 根据dsl节点类型获取对应组件
+     *
+     * @remarks
+     * - {@link DslDefinitionType#VIEW} resolve rule: `{@link DEFAULT_TAG_PREFIX}-{@link DslDefinition#dslNodeType}` (Unsupported auto resolve methods)<br />
+     * - {@link DslDefinitionType#PACK} resolve rule: `{@link PackDslDefinition#widget}` (Supported auto resolve methods)<br>
+     * - {@link DslDefinitionType#ELEMENT} resolve rule: `{@link ElementDslDefinition#widget}` (Supported auto resolve methods)<br>
+     * - Others resolve rule: `{@link DslDefinition#dslNodeType}` (Unsupported auto resolve methods)
+     *
+     * @param dslDefinition dsl定义
+     * @return
+     * - 正确获取组件时返回: Component | string;
+     * - 未知类型、插槽或模板类型返回: null;
+     * - 无效的dslNodeType返回: undefined
+     */
+    static fetchComponent(dslDefinition: DslDefinition): ResolveComponentType | null | undefined;
+    private static createVNodeChildren;
+    private static createVNodeWithDslDefinition;
+    private static resolveMethods;
+    private static resolveCommonWidgetComponent;
+    private static resolveWidgetComponent;
+}
+export {};

package/dist/types/src/util/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dsl-render';
+export * from './install';
+export * from './render';
+export * from './widget-manager';

package/dist/types/src/util/install.d.ts

@@ -0,0 +1,4 @@
+import { Component, Directive, Plugin } from 'vue';
+export declare function componentInstall(component: Component, name?: string | string[]): void;
+export declare function directiveInstall(directive: Directive, name: string): void;
+export declare function pluginInstall(plugin: Plugin, ...options: unknown[]): void;

package/dist/types/src/util/render.d.ts

@@ -0,0 +1,7 @@
+import { Slots, VNode } from 'vue';
+import { VueWidget } from '../basic';
+export declare function renderWidgets(widgets: VueWidget[], ctx: Record<string, unknown>, slots?: Slots): VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined;

package/dist/types/src/util/widget-manager.d.ts

@@ -0,0 +1,4 @@
+import { VueWidget } from '../basic';
+export declare function newVueWidget(): VueWidget;
+export declare function getWidget(handler: string): VueWidget | undefined;
+export declare function getWidgetNotNull(handle: string): VueWidget;

package/dist/types/src/view/index.d.ts

@@ -0,0 +1,161 @@
+import { EntityBody, IViewProps, ListVM, ObjectVM, RuntimeModel } from '@oinone/kunlun-engine';
+import { LifeCycleTypes, ViewEventName } from '@oinone/kunlun-event';
+import { Entity, IDslNode, IModel, IView, ViewElement, ViewId, ViewType } from '@oinone/kunlun-meta';
+import { Matched } from '@oinone/kunlun-router';
+import { Constructor } from '@oinone/kunlun-shared';
+import { SPIOptions, SPISingleSelector, SPITokenFactory } from '@oinone/kunlun-spi';
+import { DslNodeWidget } from '../dsl/DslNodeWidget';
+export interface IViewFilterOptions extends SPIOptions {
+    id?: ViewId[] | ViewId;
+    name?: string[] | string;
+    type?: ViewType[] | ViewType;
+    model?: string[] | string;
+    widget?: string[] | string;
+    tagName?: string[] | string;
+}
+declare type WatchCb<T> = (value: T, oldValue: T) => void;
+export declare abstract class ViewWidget<ViewData = any, VP extends IViewProps = any, VM extends ListVM | ObjectVM = any> extends DslNodeWidget<VP> {
+    static Token: SPITokenFactory<IViewFilterOptions>;
+    static Selector: SPISingleSelector<IViewFilterOptions, Constructor<ViewWidget>>;
+    protected loading: boolean;
+    protected currentRoute: Matched;
+    rootData: EntityBody;
+    private subjectRoute$;
+    private $$vm;
+    getVM(): VM;
+    setVM($$vm: VM): void;
+    /**
+     * 设置loading
+     */
+    setBusy(busy: boolean): void;
+    /**
+     * 获取url参数
+     *
+     * @returns {Record<string, string>}
+     */
+    getUrlParams(): any;
+    /**
+     * 获取当前是否处于loading状态
+     */
+    getBusy(): boolean;
+    initialize(props: VP): this;
+    protected domain: string;
+    private filter;
+    private parentRootHandlerStr;
+    private currentRootHandlerStr;
+    private get rootHandleStr();
+    isRootView: boolean;
+    /**
+     * 监听视图的事件
+     * @param  event 事件名 / 事件对象
+     * @param  handler? 回调函数
+     *
+     * @example
+     *
+     * 单个事件监听
+     * viewWidget.on('change', (fieldInstance) => {})
+     * viewWidget.on('blur', (fieldInstance) => {})
+     */
+    on<V = ViewWidget>(event: {
+        [key in ViewEventName]?: (view: V) => void;
+    }): void;
+    /**
+     * 多个事件监听
+     *
+     * @example
+     *
+     * viewWidget.on({
+     *  change(fieldInstance) => {},
+     *  blur(fieldInstance) => {},
+     * })
+     */
+    on<V = ViewWidget>(event: ViewEventName, handler: (view: V) => void): void;
+    /**
+     * 用来监听视图数据的的变化
+     *
+     * @param {(value, oldValue):void} cb 监听数据发生变化的回调函数
+     * @param {object} options 可配置选项
+     *         watchKey -> 当key对应的value发生变化后，才会触发回调用函数
+     *                      "如果要监听的数据是对象，那么该参数不会生效"
+     *         distinct -> 是否去重（当上一个值跟当前的值相当的时候，就不会处理）
+     *
+     * @example
+     * const widget = this.createWidget(FormWidget, undefined, {....})
+     * widget.watch((value) => {....})
+     *
+     */
+    watch(cb: WatchCb<ViewData>): any;
+    watch(cb: WatchCb<ViewData>, options: {
+        watchKey?: string;
+        distinct?: boolean;
+    }): any;
+    watch(cb: WatchCb<ViewData>, options: {
+        watchKey?: string[];
+        distinct?: boolean;
+    }): any;
+    /**
+     * 如果没有key，就不做任何处理
+     * 如果key不是字符串类型，也不是数组类型，那么不做任何处理
+     */
+    protected filterWatchData(pre: ViewData, next: ViewData, key: string | string[]): boolean;
+    isDialogView: boolean;
+    /**
+     * 当前的widget是不是更节点
+     */
+    get isRoot(): boolean;
+    get useConstruct(): boolean;
+    private selfHandleStr;
+    view: IView;
+    protected model: RuntimeModel | null;
+    protected type: 'FORM' | 'TABLE' | 'UNKNOWN';
+    /**
+     * 页面默认的参数, A页面跳转到B页面，期望能带入参数过去
+     */
+    protected initQueryParams: Record<string, string> | null;
+    get viewElement(): ViewElement | any;
+    protected resolveTemplate(): void;
+    fetchData(data?: Entity[], options?: any, variables?: Record<string, unknown>): unknown;
+    onRowsChange(data: any[]): void;
+    loadData(data: ViewData, reset?: boolean): unknown;
+    /**
+     * 加载`rootData` 数据
+     */
+    loadRootData(content: any): void;
+    setRootDataByKey(key: string, value: any): void;
+    submit(): unknown;
+    getData(): ViewData;
+    setData(content: ViewData): void;
+    validator(): Promise<any[]>;
+    /**
+     * 加载元数据，允许被重写
+     *
+     * @param  {IModel} model 模型
+     * @param  {IDslNode} dslNode? dslNode，如果不传入，会自动创建
+     * @param  {IView} view? 视图，如果不传入，会自动创建
+     * @param  {ViewType} viewType? 指定视图类型
+     */
+    loadMetadata(model: IModel, dslNode?: IDslNode, view?: IView, viewType?: ViewType): void;
+    getActiveRecords(): Entity[];
+    setDomain(domain: string): void;
+    getDomain(): string;
+    setFilter(f: string): void;
+    getFilter(): string;
+    getModel(): IModel;
+    getView(): IView;
+    path: string;
+    getPath(): string;
+    notify(type: LifeCycleTypes): void;
+    $$beforeCreated(): void;
+    $$created(): void;
+    $$beforeMount(): void;
+    $$mounted(): void;
+    $$beforeUpdate(): void;
+    $$updated(): void;
+    $$beforeUnmount(): void;
+    $$unmounted(): void;
+}
+/**
+ * @deprecated 移动端未修改，必须移除该定义
+ */
+export declare const ViewSubSymbol: unique symbol;
+export {};

package/index.ts

@@ -0,0 +1 @@
+export * from './src';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@oinone/kunlun-vue-widget",
+  "version": "6.2.0",
+  "main": "index.ts",
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "rollup -c",
+    "dist": "npm run prepublishOnly",
+    "index": "npm run postpublish",
+    "x-prepublishOnly": "node ../../scripts/prepublish-only.js",
+    "x-postpublish": "node ../../scripts/postpublish.js"
+  },
+  "dependencies": {
+    "@oinone/kunlun-vue-ui-common": "6.2.0"
+  },
+  "devDependencies": {
+    "@oinone/kunlun-dsl": "~6.2.0",
+    "@oinone/kunlun-engine": "~6.2.0",
+    "@oinone/kunlun-event": "~6.2.0",
+    "@oinone/kunlun-meta": "~6.2.0",
+    "@oinone/kunlun-router": "~6.2.0",
+    "@oinone/kunlun-shared": "~6.2.0",
+    "@oinone/kunlun-spi": "~6.2.0",
+    "@oinone/kunlun-state": "~6.2.0",
+    "@types/lodash": "4.14.182",
+    "@types/lodash-es": "4.17.6",
+    "lodash": "4.17.21",
+    "lodash-es": "4.17.21"
+  },
+  "peerDependencies": {
+    "vue": ">=3.2.40"
+  },
+  "gitHead": "b65bbf1d649da1017810c5608473d5daa1a41f94"
+}

package/rollup.config.js

@@ -0,0 +1,21 @@
+import pkg from './package.json';
+import rollupConfig from '../../scripts/build.config.js';
+
+export default rollupConfig(
+  pkg.name,
+  [
+    '@oinone/kunlun-dsl',
+    '@oinone/kunlun-engine',
+    '@oinone/kunlun-event',
+    '@oinone/kunlun-meta',
+    '@oinone/kunlun-router',
+    '@oinone/kunlun-shared',
+    '@oinone/kunlun-spi',
+    '@oinone/kunlun-state',
+    '@oinone/kunlun-vue-ui-common',
+    'lodash',
+    'lodash-es',
+    'vue'
+  ],
+  false
+);

package/src/basic/AsyncVueWidget.ts

@@ -0,0 +1,31 @@
+import { h, Suspense, VNode, SetupContext } from 'vue';
+import { SetupHook, VueWidget } from './VueWidget';
+
+export class AsyncVueWidget extends VueWidget {
+  public setup(setupHook?: SetupHook) {
+    const setupFunction = super.setup();
+    return async (ctx: void, props?: unknown) => {
+      const result = setupFunction(ctx, props);
+      const hookResult: Record<string, unknown> = ((setupHook && (await setupHook(ctx, props))) || {}) as Record<
+        string,
+        unknown
+      >;
+      for (const key in hookResult) {
+        Reflect.set(result, key, Reflect.get(hookResult, key));
+      }
+      return result;
+    };
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public render(ctx?: SetupContext | any): VNode {
+    return h('div', h(Suspense, super.render(ctx) as VNode));
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async setupHook(_ctx: void, _props: unknown, _result: unknown): Promise<unknown> {
+    await this.beforeCreated();
+    await this.created();
+    return {};
+  }
+}

package/src/basic/VueFragment.vue

@@ -0,0 +1,11 @@
+<script lang="ts">
+import { createVNode, defineComponent, Fragment } from 'vue';
+
+export default defineComponent({
+  name: 'VueFragment',
+  inheritAttrs: false,
+  render() {
+    return createVNode(Fragment, undefined, this.$slots.default?.() || []);
+  }
+});
+</script>