@maketribe/ms-app 3.0.30 → 3.0.32

package/src/components/condition-components/condition-number/condition-number-options.ts

@@ -0,0 +1,22 @@
+import { ExtractPropTypes } from "vue";
+import { buildProps } from "@maketribe/utils";
+
+import {
+  dataFilterConditionProps,
+  EQUAL_OPTION,
+} from "../../data-model/data-filter-form";
+
+export const conditionNumberProps = buildProps({
+  ...dataFilterConditionProps,
+  defaultValue: {
+    default: null,
+  },
+  defaultOperator: {
+    type: String,
+    default: EQUAL_OPTION.value,
+  },
+});
+
+export type ConditionNumberProps = ExtractPropTypes<
+  typeof conditionNumberProps
+>;

package/src/components/condition-components/condition-number/condition-number.tsx

@@ -0,0 +1,74 @@
+import { ElInputNumber } from "element-plus";
+import { defineComponent, unref } from "vue";
+import { Operator } from "@maketribe/dm";
+
+import {
+  useDataFilterCondition,
+  BETWEEN_OPTION,
+  EQUAL_OPTION,
+  GREATER_THAN_EQUAL_OPTION,
+  GREATER_THAN_OPTION,
+  LESS_THAN_EQUAL_OPTION,
+  LESS_THAN_OPTION,
+} from "../../data-model/data-filter-form";
+import { conditionNumberProps } from "./condition-number-options";
+
+export default defineComponent({
+  name: "MKConditionNumber",
+  props: conditionNumberProps,
+  setup(props, { expose }) {
+    const { value, isBetween } = useDataFilterCondition({
+      ...props,
+      operator: props.defaultOperator as Operator,
+      operatorOptions: [
+        EQUAL_OPTION,
+        BETWEEN_OPTION,
+        LESS_THAN_OPTION,
+        LESS_THAN_EQUAL_OPTION,
+        GREATER_THAN_OPTION,
+        GREATER_THAN_EQUAL_OPTION,
+      ],
+    });
+
+    expose({
+      isEmpty() {
+        return value.value == null;
+      },
+      reset() {
+        value.value = null;
+      },
+    });
+
+    return () => {
+      const children = unref(isBetween) ? (
+        <span>
+          <ElInputNumber
+            modelValue={unref(value)[0]}
+            onUpdate:modelValue={(v) => (value.value[0] = v)}
+            controls-position="right"
+          />
+
+          <ElInputNumber
+            modelValue={unref(value)[1]}
+            onUpdate:modelValue={(v) => (value.value[1] = v)}
+            controls-position="right"
+          />
+        </span>
+      ) : (
+        <ElInputNumber
+          modelValue={unref(value)}
+          onUpdate:modelValue={(v) => (value.value = v)}
+          controls-position="right"
+        />
+      );
+
+      return (
+        <div
+          class={["mk-condition-number", unref(isBetween) ? "is-between" : ""]}
+        >
+          {children}
+        </div>
+      );
+    };
+  },
+});

package/src/components/condition-components/condition-number/index.ts

@@ -0,0 +1,7 @@
+import { withInstall } from "@maketribe/utils";
+import ConditionNumber from "./condition-number";
+
+export const MKConditionNumber = withInstall(ConditionNumber);
+export default MKConditionNumber;
+
+export * from "./condition-number-options";

package/src/components/condition-components/condition-select/condition-select-options.ts

@@ -0,0 +1,31 @@
+import { ExtractPropTypes } from "vue";
+import { buildProps } from "@maketribe/utils";
+import { DataTable } from "@maketribe/dm";
+import { dataFilterConditionProps } from "../../data-model/data-filter-form";
+
+export const conditionSelectProps = buildProps({
+  ...dataFilterConditionProps,
+  multiple: {
+    type: Boolean,
+    default: false,
+  },
+  source: {
+    type: Object,
+  },
+  options: {
+    type: Array,
+  },
+  dataTable: {
+    type: DataTable<any>,
+  },
+});
+
+export type ConditionSelectProps = ExtractPropTypes<
+  typeof conditionSelectProps
+>;
+
+export const conditionSelectEmit = {
+  "update:model-value": (modelValue: any) => true,
+};
+
+export type ConditionSelectEmit = typeof conditionSelectEmit;

package/src/components/condition-components/condition-select/condition-select.tsx

@@ -0,0 +1,56 @@
+import { defineComponent, unref } from "vue";
+
+import { conditionSelectProps } from "./condition-select-options";
+import {
+  useDataFilterCondition,
+  IN_OPTION,
+  NOT_IN_OPTION,
+} from "../../data-model/data-filter-form";
+import { MKDataSelect } from "../../data-select";
+
+export default defineComponent({
+  name: "MKConditionSelect",
+  props: conditionSelectProps,
+  setup(props, { expose }) {
+    const { value } = useDataFilterCondition({
+      ...props,
+      defaultValue: props.defaultValue
+        ? props.defaultValue
+        : props.multiple
+        ? []
+        : "",
+      operator: IN_OPTION.value,
+      operatorOptions: [IN_OPTION, NOT_IN_OPTION],
+    });
+
+    expose({
+      isEmpty() {
+        if (props.multiple) {
+          return !Array.isArray(value.value) || value.value.length === 0;
+        }
+
+        return value.value == null;
+      },
+      reset() {
+        if (props.multiple) {
+          value.value = [];
+        } else {
+          value.value = null;
+        }
+      },
+    });
+
+    return () => {
+      return (
+        <MKDataSelect
+          modelValue={unref(value)}
+          dataTable={props.dataTable}
+          options={props.options}
+          source={props.source!}
+          multiple={props.multiple}
+          onUpdate:model-value={(v: any) => (value.value = v)}
+        />
+      );
+    };
+  },
+});

package/src/components/condition-components/condition-select/index.ts

@@ -0,0 +1,7 @@
+import { withInstall } from "@maketribe/utils";
+import ConditionSelect from "./condition-select";
+
+export const MKConditionSelect = withInstall(ConditionSelect);
+export default MKConditionSelect;
+
+export * from "./condition-select-options";

package/src/components/condition-components/index.ts

@@ -0,0 +1,4 @@
+export * from "./condition-input";
+export * from "./condition-date";
+export * from "./condition-number";
+export * from "./condition-select";

package/src/components/config-provider/config-provider-options.ts

@@ -0,0 +1,24 @@
+import { ExtractPropTypes } from "vue";
+import { Components } from "@maketribe/dm";
+import { buildProps } from "@maketribe/utils";
+import { I18n } from "@maketribe/locale";
+
+export const configProviderProps = buildProps({
+  dataTableComponents: {
+    type: Components,
+  },
+  dataFormComponents: {
+    type: Components,
+  },
+  dataFilterComponents: {
+    type: Components,
+  },
+  whereFilterComponents: {
+    type: Components,
+  },
+  i18n: {
+    type: I18n,
+  },
+});
+
+export type ConfigProviderProps = ExtractPropTypes<typeof configProviderProps>;

package/src/components/config-provider/config-provider.tsx

@@ -0,0 +1,21 @@
+import { computed, defineComponent, provide, renderSlot, unref } from "vue";
+import { provideGlobalConfig } from "./use-global-config";
+import { configProviderProps } from "./config-provider-options";
+import { ElConfigProvider } from "element-plus";
+
+export default defineComponent({
+  name: "MKConfigProvider",
+  inheritAttrs: false,
+  props: configProviderProps,
+  setup(props, { slots }) {
+    provideGlobalConfig(props);
+
+    const currentLocale = computed(() => props.i18n?.currentLanguage as any);
+
+    return () => (
+      <ElConfigProvider locale={unref(currentLocale)}>
+        {renderSlot(slots, "default")}
+      </ElConfigProvider>
+    );
+  },
+});

package/src/components/config-provider/constants.ts

@@ -0,0 +1,8 @@
+import { InjectionKey, Ref } from "vue";
+import { ConfigProviderProps } from "./config-provider-options";
+
+export type ConfigProviderContext = Partial<ConfigProviderProps>;
+
+export const CONFIG_PROVIDER_CONTEXT_KEY: InjectionKey<
+  Ref<ConfigProviderContext>
+> = Symbol("configProviderContextKey");

package/src/components/config-provider/index.ts

@@ -0,0 +1,9 @@
+import { withInstall } from "@maketribe/utils";
+import ConfigProvider from "./config-provider";
+
+export const MKConfigProvider = withInstall(ConfigProvider);
+
+export default MKConfigProvider;
+
+export * from "./use-global-config";
+export * from "./constants";

package/src/components/config-provider/use-global-config.ts

@@ -0,0 +1,70 @@
+import {
+  App,
+  MaybeRef,
+  Ref,
+  computed,
+  getCurrentInstance,
+  inject,
+  provide,
+  ref,
+  unref,
+} from "vue";
+import merge from "lodash-es/merge";
+import {
+  CONFIG_PROVIDER_CONTEXT_KEY,
+  ConfigProviderContext,
+} from "./constants";
+
+const globalConfig = ref<ConfigProviderContext>();
+
+export function useGlobalConfig<
+  K extends keyof ConfigProviderContext,
+  D extends ConfigProviderContext[K]
+>(key?: K, defaultValue?: D): Ref<ConfigProviderContext[K] | D>;
+export function useGlobalConfig(): Ref<ConfigProviderContext>;
+export function useGlobalConfig(
+  key?: keyof ConfigProviderContext,
+  defaultValue = undefined
+) {
+  const config = getCurrentInstance()
+    ? inject(CONFIG_PROVIDER_CONTEXT_KEY, globalConfig)
+    : globalConfig;
+
+  if (key) {
+    return computed(() => unref(config)?.[key] ?? defaultValue);
+  }
+
+  return config;
+}
+
+export function provideGlobalConfig(
+  config: MaybeRef<ConfigProviderContext>,
+  app?: App,
+  global: boolean = false
+) {
+  const inSetup = !!getCurrentInstance();
+  const oldConfig = inSetup ? useGlobalConfig() : globalConfig;
+
+  const provideFn = app?.provide ?? (inSetup ? provide : undefined);
+
+  if (!provideFn) {
+    throw new Error("");
+  }
+
+  const context = computed(() => {
+    const cfg = unref(config);
+    if (!oldConfig?.value) {
+      return cfg;
+    }
+
+    return merge(oldConfig.value, cfg);
+  });
+
+  provide(CONFIG_PROVIDER_CONTEXT_KEY, context);
+
+  if (global || !globalConfig.value) {
+    globalConfig.value = context.value;
+  }
+
+  return context;
+}

package/src/components/data-model/data-filter-form/composables/index.ts

@@ -0,0 +1 @@
+export * from "./use-condition";

package/src/components/data-model/data-filter-form/composables/use-condition.ts

@@ -0,0 +1,68 @@
+import { computed, inject, unref, watch } from "vue";
+import { buildProps } from "@maketribe/utils";
+import { Operator } from "@maketribe/dm";
+
+import { BETWEEN_OPTION, OperatorOption } from "../operator-options";
+import { DATA_FILTER_ITEM_CONTEXT } from "../token";
+
+export const dataFilterConditionProps = buildProps({
+  defaultValue: {
+    default: null,
+  },
+} as const);
+
+export type DataFilterConditionOptions = {
+  operator: Operator;
+  operatorOptions: OperatorOption[];
+  defaultValue: any;
+};
+
+export function useDataFilterCondition(options: DataFilterConditionOptions) {
+  const dataFilterItemContext = inject(DATA_FILTER_ITEM_CONTEXT)!;
+  const dataFilterItem = dataFilterItemContext.dataFilterItem;
+
+  dataFilterItem.setOperatorOptions(options.operatorOptions);
+
+  dataFilterItem.setOperator(options.operator);
+  if (options.defaultValue !== void 0) {
+    dataFilterItem.column.defaultValue = options.defaultValue;
+  }
+
+  const value = computed({
+    get: () => dataFilterItem.getValue(),
+    set: (v: any) => dataFilterItem.setValue(v === "" ? null : v),
+  });
+
+  const isBetween = computed(
+    () => unref(currentOperator.value) === BETWEEN_OPTION.value
+  );
+
+  const currentOperator = computed(() => dataFilterItem.currentOperator);
+
+  const calcDefaultValue = () => {
+    const defaultValue = options.defaultValue;
+
+    if (unref(isBetween)) {
+      return [defaultValue, defaultValue];
+    }
+
+    return defaultValue;
+  };
+
+  watch(currentOperator, () => {
+    const defaultValue = calcDefaultValue();
+
+    dataFilterItem.column.defaultValue = defaultValue;
+    value.value = defaultValue;
+  });
+
+  dataFilterItem.column.defaultValue = calcDefaultValue();
+  value.value = dataFilterItem.getValue() || calcDefaultValue();
+
+  return {
+    isBetween,
+    dataFilterItem,
+    currentOperator,
+    value,
+  };
+}

package/src/components/data-model/data-filter-form/data-filter-form-item/data-filter-form-item-options.ts

@@ -0,0 +1,11 @@
+import { ExtractPropTypes } from "vue";
+import { buildProps } from "@maketribe/utils";
+
+export const dataFilterFormItemProps = buildProps({
+  name: { type: String, required: true },
+  label: { type: String },
+} as const);
+
+export type DataFilterFormItemProps = ExtractPropTypes<
+  typeof dataFilterFormItemProps
+>;

package/src/components/data-model/data-filter-form/data-filter-form-item/data-filter-form-item.tsx

@@ -0,0 +1,183 @@
+import {
+  computed,
+  defineComponent,
+  inject,
+  onBeforeUnmount,
+  provide,
+  reactive,
+  toRaw,
+  unref,
+} from "vue";
+import { DataFilter, FilterColumn, isWhereFilter } from "@maketribe/dm";
+import { useFilterColumnComponent, useI18n } from "../../../../composables";
+import { dataFilterFormItemProps } from "./data-filter-form-item-options";
+import {
+  DATA_FILTER_CONTEXT,
+  DATA_FILTER_ITEM_CONTEXT,
+  DataFilterItem,
+  DataFilterItemContext,
+} from "../token";
+import { OperatorOption } from "../operator-options";
+import { ElOption, ElSelect, ElTooltip } from "element-plus";
+
+export default defineComponent({
+  name: "MKDataFilterFormItem",
+  props: dataFilterFormItemProps,
+  setup(props, { slots }) {
+    const i18n = useI18n()!;
+
+    const dataFilterContext = inject(DATA_FILTER_CONTEXT)!;
+
+    const dataFilter = computed(() => dataFilterContext.dataFilter);
+
+    let _filterColumn: FilterColumn | null = null;
+
+    const createFilterColumn = () => {
+      _filterColumn = reactive(
+        new FilterColumn({
+          name: props.name!,
+          label: props.label!,
+        })
+      );
+
+      unref(dataFilter).addColumn(_filterColumn);
+
+      return _filterColumn;
+    };
+
+    const filterColumn = computed(() => {
+      const existingColumn = unref(dataFilter).getColumn(props.name) ?? null;
+
+      if (existingColumn) {
+        return existingColumn;
+      }
+
+      if (!_filterColumn) {
+        _filterColumn = createFilterColumn();
+      }
+
+      return _filterColumn;
+    });
+
+    const { component, componentProps } = useFilterColumnComponent(
+      filterColumn,
+      dataFilter
+    );
+
+    const createDataFilterItem = (
+      dataFilter: DataFilter,
+      column: FilterColumn
+    ) => {
+      function setOperator(
+        this: DataFilterItem,
+        operator: OperatorOption["value"]
+      ) {
+        const _dataFilter = unref(dataFilter);
+        if (isWhereFilter(_dataFilter)) {
+          this.currentOperator = operator;
+          _dataFilter.setParamOperator(unref(column).name, operator);
+        }
+      }
+
+      function setOperatorOptions(
+        this: DataFilterItem,
+        options: OperatorOption[]
+      ) {
+        if (isWhereFilter(unref(dataFilter))) {
+          this.operatorOptions = options;
+        }
+      }
+
+      function setValue(this: DataFilterItem, value: any) {
+        this.dataFilter.setParam(this.column.name, value);
+      }
+
+      function getValue(this: DataFilterItem): any {
+        return this.dataFilter.getParam(this.column.name);
+      }
+
+      const filterPanelItem: DataFilterItem = {
+        dataFilter,
+        column,
+        currentOperator: null,
+        operatorOptions: [],
+        setOperator,
+        setOperatorOptions,
+        setValue,
+        getValue,
+      };
+
+      return filterPanelItem;
+    };
+
+    const dataFilterItem = reactive(
+      createDataFilterItem(unref(dataFilter), unref(filterColumn))
+    ) as DataFilterItem;
+
+    provide(
+      DATA_FILTER_ITEM_CONTEXT,
+      reactive({ dataFilter, dataFilterItem }) as DataFilterItemContext
+    );
+
+    onBeforeUnmount(() => {
+      const _filterPanel = unref(dataFilter);
+
+      if (isWhereFilter(_filterPanel)) {
+        _filterPanel.deleteParamOperator(unref(filterColumn).name);
+      }
+
+      _filterPanel.deleteParam(unref(filterColumn).name);
+    });
+
+    return () => {
+      const _filterPanel = unref(dataFilter);
+
+      const _filterColumn = unref(filterColumn);
+
+      if (!_filterColumn) {
+        return null;
+      }
+
+      let children: any = slots.default?.();
+
+      if (!children && unref(component)) {
+        const FilterColumnComponent = toRaw(unref(component));
+
+        children = <FilterColumnComponent {...unref(componentProps)} />;
+      }
+
+      const options = dataFilterItem.operatorOptions.map((option) => (
+        <ElOption
+          key={option.value}
+          value={option.value}
+          label={i18n.translate(option.label)}
+        />
+      ));
+
+      const operatorSelect = isWhereFilter(_filterPanel) ? (
+        <ElSelect
+          modelValue={dataFilterItem.currentOperator as any}
+          onUpdate:modelValue={(v) => dataFilterItem.setOperator(v)}
+          class="mk-data-filter-form-item__operator"
+        >
+          {options}
+        </ElSelect>
+      ) : null;
+
+      const labelWidth = computed(() => dataFilterContext.labelWidth);
+
+      return (
+        <div class="mk-data-filter-form-item">
+          <div
+            class="mk-data-filter-form-item__label"
+            style={{ width: labelWidth.value + "px" }}
+          >
+            {_filterColumn.label}
+          </div>
+          {/* {operatorSelect} */}
+          <div class="mk-data-filter-form-item__content">{children}</div>
+        </div>
+      );
+    };
+  },
+});

package/src/components/data-model/data-filter-form/data-filter-form-item/index.ts

@@ -0,0 +1,7 @@
+import { withInstall } from "@maketribe/utils";
+import DataFilterFormItem from "./data-filter-form-item";
+
+export const MKDataFilterFormItem = withInstall(DataFilterFormItem);
+export default MKDataFilterFormItem;
+
+export * from "./data-filter-form-item-options";

package/src/components/data-model/data-filter-form/data-filter-form-options.ts

@@ -0,0 +1,15 @@
+import { ExtractPropTypes } from "vue";
+import { DataFilter, DataTable } from "@maketribe/dm";
+import { buildProps } from "@maketribe/utils";
+import dataFilterForm from "./data-filter-form";
+
+export const dataFilterFormProps = buildProps({
+  // dataFilter: { type: DataFilter, required: true },
+  dataTable: { type: DataTable, required: true },
+} as const);
+
+export type DataFilterFormProps = ExtractPropTypes<typeof dataFilterFormProps>;
+
+export const dataFilterFormEmits = {};
+
+export type DataFilterFormEmits = typeof dataFilterForm;