@maketribe/ms-app 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/esm/table-DoBa7FPy.js

@@ -0,0 +1,69 @@
+import { defineComponent, ref, watch, computed, unref, openBlock, createBlock, createCommentVNode } from "vue";
+import { useRouter } from "vue-router";
+import "@maketribe/dm";
+import "element-plus";
+import "@maketribe/utils";
+import { w as DataModelDefines, f as MKDataTable } from "./index-Fqju8eWa.js";
+import "@maketribe/request";
+import "@maketribe/locale";
+import "lodash-es";
+import "vue-cropper";
+import "@lexical/overflow";
+import "@lexical/text";
+import "@lexical/utils";
+import "lexical";
+import "@lexical/selection";
+import "@lexical/link";
+import "@lexical/rich-text";
+import "@element-plus/icons-vue";
+import "@lexical/history";
+import "@lexical/dragon";
+import "@lexical/plain-text";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "table",
+  setup(__props) {
+    const router = useRouter();
+    const dataTable = ref(null);
+    watch(
+      computed(() => unref(router.currentRoute).meta.name),
+      ([_dataTable, name]) => {
+        dataTable.value = DataModelDefines.instance.getDataTable(name);
+      },
+      { immediate: true }
+    );
+    watch(
+      dataTable,
+      (dataTable2, _, onCleanup) => {
+        if (dataTable2) {
+          dataTable2.addRecordEvent.on(() => {
+            router.push({ name: `dv/${dataTable2.name}/edit` });
+          });
+          dataTable2.editRecordEvent.on(({ item }) => {
+            router.push({
+              name: `dv/${dataTable2.name}/edit`,
+              params: { id: item[dataTable2 == null ? void 0 : dataTable2.primaryKey] }
+            });
+          });
+        }
+        onCleanup(() => {
+          dataTable2 == null ? void 0 : dataTable2.clearSelection();
+          dataTable2 == null ? void 0 : dataTable2.dispose();
+        });
+      },
+      { immediate: true }
+    );
+    return (_ctx, _cache) => {
+      return dataTable.value ? (openBlock(), createBlock(unref(MKDataTable), {
+        key: 0,
+        mode: "page",
+        dataTable: dataTable.value,
+        selection: "",
+        enableQueryParams: ""
+      }, null, 8, ["dataTable"])) : createCommentVNode("", true);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=table-DoBa7FPy.js.map

package/dist/esm/table-DoBa7FPy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-DoBa7FPy.js","sources":["../../src/pages/index/dv/default/table.vue"],"sourcesContent":["<template>\n  <MKDataTable mode=\"page\" v-if=\"dataTable\" :dataTable=\"dataTable\" selection enableQueryParams />\n</template>\n<script setup lang=\"ts\">\nimport { unref, computed, watch, ref, Ref } from \"vue\";\nimport { useRouter } from \"vue-router\";\nimport { DataTable } from \"@maketribe/dm\";\nimport { DataModelDefines } from \"../../../../core\";\nimport {MKDataTable} from \"../../../../components\";\n\nconst router = useRouter();\n\nconst dataTable: Ref<DataTable | null> = ref(null);\n\nwatch(\n  computed(() => unref(router.currentRoute).meta.name as string),\n  ([_dataTable, name]) => {\n    dataTable.value = DataModelDefines.instance.getDataTable(name as string);\n  },\n  { immediate: true }\n);\n\nwatch(\n  dataTable,\n  (dataTable, _, onCleanup) => {\n    if (dataTable) {\n      dataTable.addRecordEvent.on(() => {\n        router.push({ name: `dv/${dataTable.name}/edit` });\n      });\n\n      dataTable.editRecordEvent.on(({ item }) => {\n        router.push({\n          name: `dv/${dataTable.name}/edit`,\n          params: { id: item[dataTable?.primaryKey as string] },\n        });\n      });\n    }\n\n    onCleanup(() => {\n      dataTable?.clearSelection();\n      dataTable?.dispose();\n    });\n  },\n  { immediate: true }\n);\n</script>\n"],"names":["dataTable"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAUA,UAAM,SAAS;AAET,UAAA,YAAmC,IAAI,IAAI;AAEjD;AAAA,MACE,SAAS,MAAM,MAAM,OAAO,YAAY,EAAE,KAAK,IAAc;AAAA,MAC7D,CAAC,CAAC,YAAY,IAAI,MAAM;AACtB,kBAAU,QAAQ,iBAAiB,SAAS,aAAa,IAAc;AAAA,MACzE;AAAA,MACA,EAAE,WAAW,KAAK;AAAA,IAAA;AAGpB;AAAA,MACE;AAAA,MACA,CAACA,YAAW,GAAG,cAAc;AAC3B,YAAIA,YAAW;AACbA,qBAAU,eAAe,GAAG,MAAM;AAChC,mBAAO,KAAK,EAAE,MAAM,MAAMA,WAAU,IAAI,SAAS;AAAA,UAAA,CAClD;AAEDA,qBAAU,gBAAgB,GAAG,CAAC,EAAE,WAAW;AACzC,mBAAO,KAAK;AAAA,cACV,MAAM,MAAMA,WAAU,IAAI;AAAA,cAC1B,QAAQ,EAAE,IAAI,KAAKA,yCAAW,UAAoB,EAAE;AAAA,YAAA,CACrD;AAAA,UAAA,CACF;AAAA,QACH;AAEA,kBAAU,MAAM;AACdA,mDAAW;AACXA,mDAAW;AAAA,QAAQ,CACpB;AAAA,MACH;AAAA,MACA,EAAE,WAAW,KAAK;AAAA,IAAA;;;;;;;;;;;;"}

package/dist/esm/use-condition-CM-TzG8I.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-condition-CM-TzG8I.js","sources":["../../src/components/data-model/data-filter-form/composables/use-condition.ts"],"sourcesContent":["import { buildProps } from \"@maketribe/utils\";\r\nimport { FilterColumn, Operator } from \"@maketribe/dm\";\r\n\r\nimport { OperatorOption } from \"../operator-options\";\r\n\r\nexport const dataFilterConditionProps = buildProps({\r\n  modelValue: {\r\n    type: null,\r\n  },\r\n  defaultValue: {\r\n    default: null,\r\n  },\r\n  column: {\r\n    type: FilterColumn,\r\n    required: true,\r\n  },\r\n} as const);\r\n\r\nexport type DataFilterConditionOptions = {\r\n  operator: Operator;\r\n  operatorOptions: OperatorOption[];\r\n  defaultValue: any;\r\n};\r\n\r\n// export function useDataFilterCondition(options: DataFilterConditionOptions) {\r\n//   const dataFilterItemContext = inject(DATA_FILTER_ITEM_CONTEXT)!;\r\n//   const dataFilterItem = dataFilterItemContext.dataFilterItem;\r\n\r\n//   dataFilterItem.setOperatorOptions(options.operatorOptions);\r\n\r\n//   dataFilterItem.setOperator(options.operator);\r\n//   // if (options.defaultValue !== void 0) {\r\n//   //   dataFilterItem.column.defaultValue = options.defaultValue;\r\n//   // }\r\n\r\n//   const value = computed({\r\n//     get: () => dataFilterItem.getValue(),\r\n//     set: (v: any) => dataFilterItem.setValue(v === \"\" ? null : v),\r\n//   });\r\n\r\n//   const isBetween = computed(\r\n//     () => unref(currentOperator.value) === BETWEEN_OPTION.value\r\n//   );\r\n\r\n//   const currentOperator = computed(() => dataFilterItem.currentOperator);\r\n\r\n//   const calcDefaultValue = () => {\r\n//     const defaultValue = options.defaultValue;\r\n\r\n//     if (unref(isBetween) && !Array.isArray(defaultValue)) {\r\n//       return [defaultValue, defaultValue];\r\n//     }\r\n\r\n//     return defaultValue;\r\n//   };\r\n\r\n//   watch(currentOperator, () => {\r\n//     const defaultValue =\r\n//       dataFilterItem.column.defaultValue || calcDefaultValue();\r\n\r\n//     dataFilterItem.column.defaultValue = defaultValue;\r\n//     value.value = defaultValue;\r\n//   });\r\n\r\n//   dataFilterItem.column.defaultValue =\r\n//     dataFilterItem.column.defaultValue || calcDefaultValue();\r\n//   value.value = dataFilterItem.getValue() || calcDefaultValue();\r\n\r\n//   return {\r\n//     isBetween,\r\n//     dataFilterItem,\r\n//     currentOperator,\r\n//     value,\r\n//   };\r\n// }\r\n"],"names":[],"mappings":";;AAKO,MAAM,2BAA2B,WAAW;AAAA,EACjD,YAAY;AAAA,IACV,MAAM;AAAA,EACR;AAAA,EACA,cAAc;AAAA,IACZ,SAAS;AAAA,EACX;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,UAAU;AAAA,EACZ;AACF,CAAU;"}
+{"version":3,"file":"use-condition-CM-TzG8I.js","sources":["../../src/components/data-model/data-filter-form/composables/use-condition.ts"],"sourcesContent":["import { buildProps } from \"@maketribe/utils\";\nimport { FilterColumn, Operator } from \"@maketribe/dm\";\n\nimport { OperatorOption } from \"../operator-options\";\n\nexport const dataFilterConditionProps = buildProps({\n  modelValue: {\n    type: null,\n  },\n  defaultValue: {\n    default: null,\n  },\n  column: {\n    type: FilterColumn,\n    required: true,\n  },\n} as const);\n\nexport type DataFilterConditionOptions = {\n  operator: Operator;\n  operatorOptions: OperatorOption[];\n  defaultValue: any;\n};\n\n// export function useDataFilterCondition(options: DataFilterConditionOptions) {\n//   const dataFilterItemContext = inject(DATA_FILTER_ITEM_CONTEXT)!;\n//   const dataFilterItem = dataFilterItemContext.dataFilterItem;\n\n//   dataFilterItem.setOperatorOptions(options.operatorOptions);\n\n//   dataFilterItem.setOperator(options.operator);\n//   // if (options.defaultValue !== void 0) {\n//   //   dataFilterItem.column.defaultValue = options.defaultValue;\n//   // }\n\n//   const value = computed({\n//     get: () => dataFilterItem.getValue(),\n//     set: (v: any) => dataFilterItem.setValue(v === \"\" ? null : v),\n//   });\n\n//   const isBetween = computed(\n//     () => unref(currentOperator.value) === BETWEEN_OPTION.value\n//   );\n\n//   const currentOperator = computed(() => dataFilterItem.currentOperator);\n\n//   const calcDefaultValue = () => {\n//     const defaultValue = options.defaultValue;\n\n//     if (unref(isBetween) && !Array.isArray(defaultValue)) {\n//       return [defaultValue, defaultValue];\n//     }\n\n//     return defaultValue;\n//   };\n\n//   watch(currentOperator, () => {\n//     const defaultValue =\n//       dataFilterItem.column.defaultValue || calcDefaultValue();\n\n//     dataFilterItem.column.defaultValue = defaultValue;\n//     value.value = defaultValue;\n//   });\n\n//   dataFilterItem.column.defaultValue =\n//     dataFilterItem.column.defaultValue || calcDefaultValue();\n//   value.value = dataFilterItem.getValue() || calcDefaultValue();\n\n//   return {\n//     isBetween,\n//     dataFilterItem,\n//     currentOperator,\n//     value,\n//   };\n// }\n"],"names":[],"mappings":";;AAKO,MAAM,2BAA2B,WAAW;AAAA,EACjD,YAAY;AAAA,IACV,MAAM;AAAA,EACR;AAAA,EACA,cAAc;AAAA,IACZ,SAAS;AAAA,EACX;AAAA,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,UAAU;AAAA,EACZ;AACF,CAAU;"}

package/dist/types/application.d.ts

@@ -0,0 +1,29 @@
+import { App } from "vue";
+import 'floating-vue/dist/style.css';
+import 'overlayscrollbars/overlayscrollbars.css';
+import { Router as VueRouter } from "vue-router";
+import { MkModule, MSAppClient } from "./core";
+import { HttpRequest } from "@maketribe/request";
+export type InitMsApplicationOptions = {
+    routes: any;
+    vueRouter?: VueRouter | 'hash' | 'history';
+    app: App;
+    appID: string;
+    logo?: string;
+    projectName?: string;
+    modules: Array<MkModule>;
+    locale?: string;
+    /**
+     * 请求实例
+     */
+    httpRequest?: HttpRequest;
+    /**
+     * ui 设置
+     */
+    uiSettings?: Record<string, any>;
+};
+/**
+ * 初始化应用
+ * @param options
+ */
+export declare const initApplication: (options: InitMsApplicationOptions) => Promise<MSAppClient>;

package/dist/types/components/basic/ConfigProvider/composables.d.ts

@@ -0,0 +1,5 @@
+import { App, MaybeRef, Ref } from "vue";
+import { ConfigProviderContext } from "./constants";
+export declare function useGlobalConfig<K extends keyof ConfigProviderContext, D extends ConfigProviderContext[K]>(key?: K, defaultValue?: D): Ref<ConfigProviderContext[K] | D>;
+export declare function useGlobalConfig(): Ref<ConfigProviderContext>;
+export declare function provideGlobalConfig(config: MaybeRef<ConfigProviderContext>, app?: App, global?: boolean): globalThis.ComputedRef<(import("@maketribe/locale").I18n | import("@maketribe/dm").Components<import("@maketribe/dm").Component> | Partial<import("./options").ConfigProviderProps>) & Partial<import("./options").ConfigProviderProps>>;

package/dist/types/components/basic/ConfigProvider/constants.d.ts

@@ -0,0 +1,4 @@
+import { InjectionKey, Ref } from "vue";
+import { ConfigProviderProps } from "./options";
+export type ConfigProviderContext = Partial<ConfigProviderProps>;
+export declare const CONFIG_PROVIDER_CONTEXT_KEY: InjectionKey<Ref<ConfigProviderContext>>;

package/dist/types/components/basic/ConfigProvider/index.d.ts

@@ -0,0 +1,78 @@
+export declare const MKConfigProvider: import("@maketribe/utils").SFCWithInstall<import("vue").DefineComponent<{
+    dataTableComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataFormComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataFilterComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    whereFilterComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataTableHeaderComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    i18n: {
+        readonly type: globalThis.PropType<import("@maketribe/locale").I18n>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    dataTableComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataFormComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataFilterComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    whereFilterComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    dataTableHeaderComponents: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").Components<import("@maketribe/dm").Component>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    i18n: {
+        readonly type: globalThis.PropType<import("@maketribe/locale").I18n>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+}>>, {}, {}>> & Record<string, any>;
+export default MKConfigProvider;
+export * from "./composables.ts";
+export * from "./constants";

package/dist/types/components/basic/DataSelect/DataSelect.d.ts

@@ -0,0 +1,138 @@
+export type DataOptionItem = {
+    value: any;
+    label: string;
+};
+declare const _default: import("vue").DefineComponent<{
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterFieldNames: import("@maketribe/utils").PropFinalized<{
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    readonly primaryKey: StringConstructor;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly options: {
+        readonly type: globalThis.PropType<unknown[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (modelValue: any) => boolean;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterFieldNames: import("@maketribe/utils").PropFinalized<{
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    readonly primaryKey: StringConstructor;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly options: {
+        readonly type: globalThis.PropType<unknown[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}>> & {
+    "onUpdate:model-value"?: ((modelValue: any) => any) | undefined;
+}, {
+    readonly disabled: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly objectValue: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly multiple: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly formatOptions: Function;
+    readonly additional: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly clearable: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly filterable: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly allowCreate: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly filterFieldNames: string[];
+}, {}>;
+export default _default;

package/dist/types/components/basic/DataSelect/index.d.ts

@@ -0,0 +1,135 @@
+export declare const MKDataSelect: import("@maketribe/utils").SFCWithInstall<import("vue").DefineComponent<{
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterFieldNames: import("@maketribe/utils").PropFinalized<{
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    readonly primaryKey: StringConstructor;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly options: {
+        readonly type: globalThis.PropType<unknown[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (modelValue: any) => boolean;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterFieldNames: import("@maketribe/utils").PropFinalized<{
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    readonly primaryKey: StringConstructor;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly options: {
+        readonly type: globalThis.PropType<unknown[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}>> & {
+    "onUpdate:model-value"?: ((modelValue: any) => any) | undefined;
+}, {
+    readonly disabled: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly objectValue: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly multiple: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly formatOptions: Function;
+    readonly additional: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly clearable: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly filterable: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly allowCreate: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly filterFieldNames: string[];
+}, {}>> & Record<string, any>;
+export default MKDataSelect;
+export * from "./options";

package/dist/types/components/basic/DataSelect/options.d.ts

@@ -0,0 +1,66 @@
+import { ExtractPropTypes } from "vue";
+export declare const dataSelectProps: {
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly allowCreate: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly clearable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterable: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly filterFieldNames: import("@maketribe/utils").PropFinalized<{
+        (arrayLength: number): string[];
+        (...items: string[]): string[];
+        new (arrayLength: number): string[];
+        new (...items: string[]): string[];
+        isArray(arg: any): arg is any[];
+        readonly prototype: any[];
+        from<T>(arrayLike: ArrayLike<T>): T[];
+        from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+        from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+        of<T>(...items: T[]): T[];
+        fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+        fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+        readonly [Symbol.species]: ArrayConstructor;
+    }, unknown, unknown, () => never[], boolean>;
+    readonly primaryKey: StringConstructor;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly options: {
+        readonly type: globalThis.PropType<unknown[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+};
+export type DataSelectProps = ExtractPropTypes<typeof dataSelectProps>;
+export declare const dataSelectEmit: {
+    "update:model-value": (modelValue: any) => boolean;
+};
+export type DataSelectEmit = typeof dataSelectEmit;

package/dist/types/components/basic/DataTableSelect/index.d.ts

@@ -0,0 +1,79 @@
+import "./index.scss";
+export declare const MKDataTableSelect: import("@maketribe/utils").SFCWithInstall<import("vue").DefineComponent<{
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:model-value": (modelValue: any) => boolean;
+}, string, import("vue").PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    readonly dataTable: {
+        readonly type: globalThis.PropType<import("@maketribe/dm").DataTable<any, any, Record<string, any>, import("@maketribe/dm").TableColumn>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly disabled: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
+    readonly modelValue: {
+        readonly type: globalThis.PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly objectValue: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly multiple: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+    readonly primaryFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly labelFieldName: {
+        readonly type: globalThis.PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __mkPropKey: true;
+    };
+    readonly formatOptions: import("@maketribe/utils").PropFinalized<FunctionConstructor, unknown, unknown, (item: any) => {
+        value: any;
+        label: any;
+    }, boolean>;
+    readonly additional: import("@maketribe/utils").PropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
+}>> & {
+    "onUpdate:model-value"?: ((modelValue: any) => any) | undefined;
+}, {
+    readonly disabled: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly objectValue: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly multiple: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly formatOptions: Function;
+    readonly additional: import("@maketribe/utils").PropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}>> & Record<string, any>;
+export default MKDataTableSelect;