@oinone/kunlun-vue-widget 6.2.0

package/dist/types/src/basic/Widget.d.ts

@@ -0,0 +1,234 @@
+import { IWidget, WidgetConstructor, WidgetProps } from '@oinone/kunlun-engine';
+import { BehaviorSubject, Subject, Subscription } from '@oinone/kunlun-state';
+import { InnerWidgetType } from '../typing/typing';
+interface BaseWidgetSubjection<T> {
+    subscribe: (func: (data: T) => void) => Subscription;
+    subject: BehaviorSubject<T> | Subject<T>;
+}
+export interface WidgetSubjection<T> extends BaseWidgetSubjection<T> {
+    subject: Subject<T>;
+}
+export interface WidgetBehaviorSubjection<T> extends BaseWidgetSubjection<T> {
+    subject: BehaviorSubject<T>;
+}
+export declare type watcher<T> = {
+    path: string;
+    handler: (newVal: T, oldVal: T) => void;
+    options?: {
+        deep?: boolean;
+    };
+};
+export declare type HANDLE = string;
+export declare abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknown> implements IWidget<Props> {
+    private static widgetCount;
+    private static createHandle;
+    private static widgetMap;
+    private static attributeMap;
+    private static protoChainsCache;
+    private static watchMap;
+    private static nameContextMap;
+    private subscriptionMap;
+    private $$props?;
+    private static Attribute;
+    /**
+     *  添加事件监听
+     *
+     * @param  {string} path 监听的路径
+     * @param  {deep?:boolean;immediate?:boolean} options?
+     *
+     * @example
+     *
+     * @Widget.Watch('formData.name', {deep: true, immediate: true})
+     * private watchName(name: string) {
+     *   ... todo
+     * }
+     *
+     */
+    protected static Watch(path: string, options?: {
+        deep?: boolean;
+        immediate?: boolean;
+    }): <T extends Widget<WidgetProps, unknown>, K>(target: T, nativeName: string, descriptor: TypedPropertyDescriptor<(newValue: K, oldValue?: K | undefined) => void> | TypedPropertyDescriptor<(newValue: K, oldValue?: K | undefined) => Promise<void>> | TypedPropertyDescriptor<(newValue?: K | undefined, oldValue?: K | undefined) => void> | TypedPropertyDescriptor<(newValue?: K | undefined, oldValue?: K | undefined) => Promise<void>>) => void;
+    private static Sub;
+    /**
+     * 可以用来处理不同widget之间的通讯，当被订阅的时候，会将默认值发送出去
+     *
+     * @param  {Symbol} name 唯一标示
+     * @param  {unknown} value? 默认值
+     *
+     * @example
+     *
+     * const identifier = Symbol('example-sub')
+     *
+     * * field.ts * // 文件
+     *
+     * @Widget.BehaviorSubContext(identifier, {value: '这是默认值'})
+     * private exampleSub!:WidgetBehaviorSubjection<{value: string}>
+     *
+     * onValueChange() {
+     *   this.exampleSub.subject.next({value: '这是新的值'})
+     * }
+     *
+     * * other-field.ts * // 文件
+     * @Widget.BehaviorSubContext(identifier, {value: '这是默认值'})
+     * private exampleSub!:WidgetBehaviorSubjection<{value: string}>
+     *
+     * mounted() {
+     *  this.exampleSub.subscribe((value) => {
+     *    ...todo
+     *  })
+     * }
+     *
+     */
+    protected static BehaviorSubContext(name: Symbol, value?: unknown): <K extends Widget<WidgetProps, unknown>>(target: K, paramName: string) => void;
+    /**
+     * 与 `BehaviorSubContext` 一样，区别在于第一次不会发射默认值
+     *
+     * @param  {Symbol} name 唯一标示
+     * @param  {unknown} value? 默认值
+     */
+    protected static SubContext(name: Symbol, value?: unknown): <K extends Widget<WidgetProps, unknown>>(target: K, paramName: string) => void;
+    /**
+     * 将数据绑定为响应式，并且组件中可以获取该值
+     */
+    protected static Reactive(params?: {
+        displayName?: string;
+        render?: boolean;
+    }): <T extends Widget<WidgetProps, unknown>, K>(target: T, nativeName: string, description?: TypedPropertyDescriptor<K> | undefined) => void;
+    /**
+     * 将方法绑定为能够被组件获取的方法
+     */
+    protected static Method(displayName?: string): <T extends Widget<WidgetProps, unknown>, K>(target: T, nativeName: string, description?: TypedPropertyDescriptor<K> | undefined) => void;
+    static select<T extends Widget = Widget>(handle: string): T | undefined;
+    /**
+     * 获取上级注入的依赖，与 Provide 一起使用
+     *
+     * @param  {string|Symbol} injectName? 被注入的name，如果不传递，那么取target中的name
+     *
+     * @example
+     *
+     * * children.ts * // 文件
+     *
+     * @Widget.Inject('InjectName')
+     * private rootData!:
+     *
+     * 如果要将该值变为响应式，如果加上Reactive
+     *
+     *  @Widget.Reactive()
+     *  @Widget.Inject('InjectName')
+     *  private rootData!:;
+     */
+    protected static Inject(injectName?: string | Symbol): <T extends Widget<WidgetProps, unknown>>(target: T, name: string) => void;
+    /**
+     * 获取下级注入的依赖，与 Inject 一起使用
+     *
+     * @param  {string|Symbol} provideName? 被注入的name，如果不传递，那么取target中的name
+     *
+     * @example
+     *
+     * * parent.ts * // 文件
+     *
+     * @Widget.Provide('ProvideName')
+     * private rootData!:
+     *
+     * 如果要将该值变为响应式，如果加上Reactive
+     *
+     *  @Widget.Reactive()
+     *  @Widget.Provide('ProvideName')
+     *  private rootData!:;
+     */
+    protected static Provide(provideName?: string | Symbol): <T extends Widget<WidgetProps, unknown>>(target: T, name: string) => void;
+    private parent;
+    protected $$innerWidgetType: InnerWidgetType | null | undefined;
+    protected childrenInstance: Widget[];
+    protected children: Widget[];
+    protected childrenWidget: Widget[];
+    private readonly handle;
+    config: Props;
+    private name;
+    private initialized;
+    private self;
+    constructor(handle?: string);
+    protected getSelf(): Widget<WidgetProps, unknown> | null;
+    getOperator(): this;
+    initialize(config?: Props): Widget;
+    /**
+     * 销毁widget
+     *
+     * 内部会根据handle匹配到对应的widget，然后进行销毁，如果children中出现了相同的handle，那么会销毁第一个
+     */
+    dispose(force?: boolean): void;
+    /**
+     * 创建一个widget
+     *
+     * @param {Widget} constructor 对应的widget
+     * @param {string}  name? 插槽
+     * @param {IViewProps}  config? widget中initialize方法接收的参数
+     *
+     */
+    createWidget<T extends Widget>(constructor: WidgetConstructor<T['config'], T>, name?: string, config?: T['config'], specifiedIndex?: number): T;
+    getHandle(): HANDLE;
+    /**
+     * 删除指定的widget
+     */
+    deleteWidget(name: string): boolean;
+    moveChildWidget(endIndex: number, startIndex: number): void;
+    insertWidget(widget: Widget, index: number): void;
+    deleteWidgetByIndex(index: number, handle?: string): boolean;
+    getConfig(key: string): unknown;
+    getAllConfig(): Props;
+    getSibling(): Widget<WidgetProps, unknown>[] | null;
+    /**
+     * 返回当前元素在其父元素的子元素节点中的前一个元素节点，如果该元素已经是第一个元素节点，则返回 null
+     */
+    previousWidgetSibling(): Widget<WidgetProps, unknown> | null;
+    /**
+     * 返回当前元素在其父元素的子元素节点中的后一个元素节点，如果该元素已经是最后一个元素节点，则返回 null
+     */
+    nextWidgetSibling(): Widget<WidgetProps, unknown> | null;
+    /**
+     * 获取父元素
+     */
+    getParentWidget(): Widget | null;
+    /**
+     * 获取子元素
+     */
+    getChildrenWidget(): Widget<WidgetProps, unknown>[];
+    /**
+     * @inner
+     *
+     */
+    getParent(): Widget | null;
+    getName(): string;
+    getWidgetType(): string;
+    static getProtoChains<T extends Function>(obj: T): Function[];
+    private currentAttributeMapCache;
+    /**
+     * 获取所有的属性
+     */
+    getAttributes(): Map<string, string>;
+    /**
+     * 获取所有的监听事件
+     */
+    getWatchers(): watcher<unknown>[];
+    /**
+     * @deprecated 使用 getChildrenWidget()
+     *
+     * 获取所有的children
+     */
+    getChildren(): Widget[];
+    /**
+     * @inner
+     *
+     */
+    getChildrenInstance(): Widget[];
+    protected addChildrenInstance(widget: Widget): void;
+    protected getShared(injectName: string | Symbol): {
+        host?: Widget;
+        value?: unknown;
+    };
+    private releaseInjection;
+    getComputeHandler(name: string): any;
+    protected getProps(): string[];
+    abstract render(...args: any[]): R;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './Widget';
+export * from './VueWidget';
+export * from './AsyncVueWidget';

package/dist/types/src/data/ActiveRecordsWidget.d.ts

@@ -0,0 +1,246 @@
+import { ActiveRecord, ActiveRecords, DeleteActiveRecordsByEntityFunction, DeleteActiveRecordsByEntityPredict, DeleteActiveRecordsFunction, FlushActiveRecordsFunction, PushActiveRecordsFunction, PushActiveRecordsPredict, ReloadActiveRecordsFunction, SubmitCacheManager, UpdateActiveRecordsByEntityFunction, UpdateActiveRecordsByEntityPredict, UpdateActiveRecordsFunction, UpdateEntity } from '@oinone/kunlun-engine';
+import { PathWidget, PathWidgetProps } from './PathWidget';
+export interface ActiveRecordsWidgetProps extends PathWidgetProps {
+    dataSource?: ActiveRecords | null;
+    activeRecords?: ActiveRecords;
+}
+/**
+ * 数据记录组件
+ */
+export declare class ActiveRecordsWidget<Props extends ActiveRecordsWidgetProps = ActiveRecordsWidgetProps> extends PathWidget<Props> {
+    initialize(props: Props): this;
+    /**
+     * 提交缓存管理器
+     * @protected
+     */
+    protected get submitCache(): SubmitCacheManager | undefined;
+    /**
+     * 上级根数据
+     * @protected
+     */
+    protected parentRootData: ActiveRecord[] | undefined;
+    /**
+     * 当前根数据
+     * @protected
+     */
+    private currentRootData;
+    /**
+     * 提供给下级的根数据
+     * @protected
+     */
+    get rootData(): ActiveRecord[] | undefined;
+    set rootData(rootData: ActiveRecord[] | undefined);
+    getCurrentRootData(): ActiveRecord[] | undefined;
+    setCurrentRootData(rootData: ActiveRecords | undefined): void;
+    protected parentReloadRootData: ReloadActiveRecordsFunction | undefined;
+    reloadRootData(records: ActiveRecords | undefined): void;
+    /**
+     * 上级数据源
+     * @protected
+     */
+    protected parentDataSource: ActiveRecord[] | undefined;
+    /**
+     * 当前数据源
+     * @protected
+     */
+    private currentDataSource;
+    /**
+     * 提供给下级的数据源
+     * @protected
+     */
+    get dataSource(): ActiveRecord[] | undefined;
+    set dataSource(dataSource: ActiveRecord[] | undefined);
+    getCurrentDataSource(): ActiveRecord[] | null | undefined;
+    setCurrentDataSource(dataSource: ActiveRecords | null | undefined): void;
+    protected parentReloadDataSource: ReloadActiveRecordsFunction | undefined;
+    /**
+     * 重新加载数据源到当前数据源中
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private reloadDataSource: ReloadActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     */
+    reloadDataSource(records: ActiveRecords | undefined): void;
+    protected parentPushDataSource: PushActiveRecordsFunction | undefined;
+    /**
+     * 添加数据源到当前数据源中
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private pushDataSource: PushActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param predict 推送判定
+     */
+    pushDataSource(records: ActiveRecords, predict?: PushActiveRecordsPredict): void;
+    protected parentUpdateDataSource: UpdateActiveRecordsFunction | undefined;
+    /**
+     * 根据索引更新数据源
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private updateDataSource: UpdateActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     */
+    updateDataSource(records: UpdateEntity[]): void;
+    protected parentUpdateDataSourceByEntity: UpdateActiveRecordsByEntityFunction | undefined;
+    /**
+     * 根据数据更新数据源
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private updateDataSourceByEntity: UpdateDataSourceByEntityFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param predict 更新判定
+     */
+    updateDataSourceByEntity(records: ActiveRecords, predict?: UpdateActiveRecordsByEntityPredict): void;
+    protected parentDeleteDataSource: DeleteActiveRecordsFunction | undefined;
+    /**
+     * 根据索引删除数据源
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private deleteDataSource: DeleteActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param recordIndexes 数据
+     */
+    deleteDataSource(recordIndexes: number[]): void;
+    protected parentDeleteDataSourceByEntity: DeleteActiveRecordsByEntityFunction | undefined;
+    /**
+     * 根据数据删除数据源
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private deleteDataSourceByEntity: DeleteDataSourceByEntityFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param predict 删除判定
+     */
+    deleteDataSourceByEntity(records: ActiveRecords, predict?: DeleteActiveRecordsByEntityPredict): void;
+    protected parentCreateDataSourceByEntity: PushActiveRecordsFunction | undefined;
+    createDataSourceByEntity(records: ActiveRecords, predict?: PushActiveRecordsPredict): void;
+    protected parentFlushDataSource: FlushActiveRecordsFunction | undefined;
+    /**
+     * 刷新数据源（数据向上提交）
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private flushActiveRecords: FlushActiveRecordsFunction | undefined;
+     * </pre>
+     */
+    flushDataSource(): void;
+    /**
+     * 上级数据记录，不可直接修改，仅在挂载时加载到当前数据记录
+     */
+    protected parentActiveRecords: ActiveRecord[] | undefined;
+    /**
+     * 上级视图数据
+     */
+    protected parentViewActiveRecords: ActiveRecord[] | undefined;
+    /**
+     * 当前数据记录，不存在时将进行数据透传
+     */
+    private currentActiveRecords;
+    /**
+     * 提供给下级的数据记录
+     */
+    get activeRecords(): ActiveRecord[] | undefined;
+    set activeRecords(activeRecords: ActiveRecord[] | undefined);
+    getCurrentActiveRecords(): ActiveRecord[] | undefined;
+    setCurrentActiveRecords(activeRecords: ActiveRecords | undefined): void;
+    protected parentReloadActiveRecords: ReloadActiveRecordsFunction | undefined;
+    /**
+     * 重新加载数据记录到当前数据记录中
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private reloadActiveRecords: ReloadActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     */
+    reloadActiveRecords(records: ActiveRecords | undefined): void;
+    protected parentPushActiveRecords: PushActiveRecordsFunction | undefined;
+    /**
+     * 添加数据记录到当前数据记录中
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private pushActiveRecords: PushActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param predict 推送判定
+     */
+    pushActiveRecords(records: ActiveRecords, predict?: PushActiveRecordsPredict): void;
+    protected parentUpdateActiveRecords: UpdateActiveRecordsFunction | undefined;
+    /**
+     * 根据索引更新数据记录
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private updateActiveRecords: UpdateActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     */
+    updateActiveRecords(records: UpdateEntity[]): void;
+    protected parentUpdateActiveRecordsByEntity: UpdateActiveRecordsByEntityFunction | undefined;
+    /**
+     * 根据数据更新数据记录
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private updateActiveRecordsByEntity: UpdateActiveRecordsByEntityFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param updatePredict 更新判定
+     */
+    updateActiveRecordsByEntity(records: ActiveRecords, updatePredict?: UpdateActiveRecordsByEntityPredict): void;
+    protected parentDeleteActiveRecords: DeleteActiveRecordsFunction | undefined;
+    /**
+     * 根据索引删除数据记录
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private deleteActiveRecords: DeleteActiveRecordsFunction | undefined;
+     * </pre>
+     *
+     * @param recordIndexes 数据
+     */
+    deleteActiveRecords(recordIndexes: number[]): void;
+    protected parentDeleteActiveRecordsByEntity: DeleteActiveRecordsByEntityFunction | undefined;
+    /**
+     * 根据数据删除数据记录
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private deleteActiveRecordsByEntity: DeleteActiveRecordsByEntityFunction | undefined;
+     * </pre>
+     *
+     * @param records 数据
+     * @param predict 删除判定
+     */
+    deleteActiveRecordsByEntity(records: ActiveRecords, predict?: DeleteActiveRecordsByEntityPredict): void;
+    protected parentFlushActiveRecords: FlushActiveRecordsFunction | undefined;
+    /**
+     * 刷新数据记录（数据向上提交）
+     * <pre>
+     * @Widget.Method()
+     * @Widget.Inject()
+     * private flushActiveRecords: FlushActiveRecordsFunction | undefined;
+     * </pre>
+     */
+    flushActiveRecords(): void;
+}

package/dist/types/src/data/PathWidget.d.ts

@@ -0,0 +1,34 @@
+import { DslDefinitionWidgetProps, DslDefinitionWidget } from '../dsl';
+export interface PathWidgetProps extends DslDefinitionWidgetProps {
+    path?: string;
+    subPath?: string;
+    subIndex?: string | number;
+    __index?: number;
+}
+/**
+ * 路径组件
+ */
+export declare class PathWidget<Props extends PathWidgetProps = PathWidgetProps> extends DslDefinitionWidget<Props> {
+    /**
+     * 上级路径
+     */
+    protected parentPath: string | undefined;
+    /**
+     * 当前子路径
+     */
+    protected subPath: string | undefined;
+    /**
+     * 当前子路径索引
+     */
+    protected subIndex: string | number | undefined;
+    /**
+     * 当前指定路径
+     * @protected
+     */
+    protected currentPath: string | undefined;
+    /**
+     * 完整路径
+     */
+    get path(): string;
+    initialize(props: Props): this;
+}

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

@@ -0,0 +1,2 @@
+export * from './PathWidget';
+export * from './ActiveRecordsWidget';

package/dist/types/src/dsl/DslDefinitionWidget.d.ts

@@ -0,0 +1,61 @@
+import { ComputeContext, RuntimeContext, RuntimeModelField } from '@oinone/kunlun-engine';
+import { InvisibleSupported } from '../feature';
+import { DslRenderWidget, DslRenderWidgetProps } from './DslRenderWidget';
+/**
+ * dsl组件属性
+ */
+export interface DslDefinitionWidgetProps extends DslRenderWidgetProps {
+    /**
+     * 元数据视图handle
+     */
+    metadataHandle?: string;
+    /**
+     * 根组件handle（一般为视图组件）
+     */
+    rootHandle?: string;
+    /**
+     * 是否内联组件
+     */
+    inline?: boolean;
+    /**
+     * 自动组件
+     */
+    automatic?: boolean;
+}
+/**
+ * dsl定义组件
+ */
+export declare class DslDefinitionWidget<Props extends DslDefinitionWidgetProps = DslDefinitionWidgetProps> extends DslRenderWidget<Props> implements InvisibleSupported {
+    protected automatic: boolean;
+    protected metadataHandle: string | undefined;
+    getMetadataHandle(): string | undefined;
+    protected rootHandle: string | undefined;
+    getRootHandle(): string | undefined;
+    protected readonly currentHandle: string;
+    getCurrentHandle(): string;
+    protected inline: boolean | undefined;
+    protected defaultAllInvisible: boolean;
+    get allInvisible(): boolean | undefined;
+    private invisibleState;
+    private lastedInvisibleState;
+    parentInvisible: boolean | undefined;
+    get invisible(): boolean;
+    get parentInvisibleProvider(): boolean;
+    constructor(handle?: string);
+    initialize(props: Props): this;
+    get metadataRuntimeContext(): RuntimeContext;
+    get rootRuntimeContext(): RuntimeContext;
+    get rootComputeContext(): ComputeContext | undefined;
+    get rootViewRuntimeContext(): {
+        runtimeContext: RuntimeContext;
+        fields: RuntimeModelField[];
+    };
+    protected invisibleProcess(invisible: boolean | string): boolean | undefined;
+    protected childrenInvisibleProcess(): boolean;
+    protected resetInvisible(): void;
+    protected resetParentInvisible(): void;
+    protected $$mounted(): void;
+    protected $$updated(): void;
+    protected $$unmountedAfterProperties(): void;
+    protected allMounted(): void;
+}

package/dist/types/src/dsl/DslNodeWidget.d.ts

@@ -0,0 +1,42 @@
+import { DslDefinition } from '@oinone/kunlun-dsl';
+import { DslProps, RuntimeContext } from '@oinone/kunlun-engine';
+import { IDslNode } from '@oinone/kunlun-meta';
+import { VueWidget } from '../basic';
+/**
+ * @deprecated 请使用PathWidget或ActiveRecordsWidget
+ */
+export declare class DslNodeWidget<IViewProps extends DslProps = DslProps> extends VueWidget<IViewProps> {
+    protected metadataHandle: string | undefined;
+    protected rootHandle: string | undefined;
+    protected currentHandle: string;
+    protected dslNode?: IDslNode;
+    protected template: DslDefinition | undefined;
+    protected slotName: string | undefined;
+    /**
+     * 上级路径
+     */
+    protected parentPath: string | undefined;
+    /**
+     * 当前子路径
+     */
+    protected subPath: string | undefined;
+    /**
+     * 当前子路径
+     */
+    protected subIndex: string | number | undefined;
+    /**
+     * 完整路径
+     */
+    protected get widgetPath(): string;
+    protected widgetInline: boolean | undefined;
+    protected get variables(): Record<string, unknown>;
+    initialize(config: IViewProps): this;
+    getDsl(): IDslNode;
+    getSlotName(): string | undefined;
+    /**
+     * 根据标签名获取dsl
+     */
+    getDslChildrenByLabel(labelName: string): IDslNode | null | undefined;
+    get metadataRuntimeContext(): RuntimeContext | undefined;
+    get rootRuntimeContext(): RuntimeContext | undefined;
+}

package/dist/types/src/dsl/DslRenderWidget.d.ts

@@ -0,0 +1,44 @@
+import { DslDefinition, DslSlots } from '@oinone/kunlun-dsl';
+import { WidgetProps } from '@oinone/kunlun-engine';
+import { Slots, VNode } from 'vue';
+import { VueWidget } from '../basic';
+/**
+ * dsl渲染组件属性
+ */
+export interface DslRenderWidgetProps extends WidgetProps {
+    /**
+     * 内部组件
+     */
+    internal?: boolean;
+    /**
+     * 模板dsl定义
+     */
+    template?: DslDefinition;
+    /**
+     * 在父组件中的插槽名
+     */
+    slotName?: string;
+    /**
+     * 支持的插槽名称
+     */
+    slotNames?: string[];
+    /**
+     * 插槽上下文
+     */
+    slotContext?: Record<string, unknown>;
+}
+export declare class DslRenderWidget<Props extends DslRenderWidgetProps = DslRenderWidgetProps> extends VueWidget {
+    protected internal: boolean;
+    protected template: DslDefinition | undefined;
+    protected slotName: string | undefined;
+    protected supportedSlotNames: string[];
+    protected dslSlots: DslSlots | undefined;
+    protected slots: Slots | null | undefined;
+    initialize(props: Props): this;
+    getDsl(): DslDefinition;
+    getSlotName(): string | undefined;
+    render(ctx?: Record<string, unknown>, slots?: Slots): VNode | VNode[];
+    protected rawRender(ctx?: Record<string, unknown>, slots?: Slots): VNode | VNode[];
+    protected internalRender(slots?: Slots): Slots | undefined;
+    protected commonRender(slots?: Slots): Slots | undefined;
+}

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

@@ -0,0 +1,3 @@
+export * from './DslNodeWidget';
+export * from './DslDefinitionWidget';
+export * from './DslRenderWidget';

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

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

package/dist/types/src/feature/invisible-supported.d.ts

@@ -0,0 +1,11 @@
+import { Widget } from '../basic';
+declare type InvisibleGetter = () => boolean;
+/**
+ * 标记可隐藏功能支持
+ */
+export interface InvisibleSupported {
+    invisible: boolean | InvisibleGetter | undefined;
+}
+export declare function executeInvisible(invisibleSupported: InvisibleSupported | undefined): boolean;
+export declare function isAllInvisible(widgets: (Widget | InvisibleSupported)[] | undefined): boolean;
+export {};