@vc-shell/framework 1.2.4-beta.8 → 2.0.0-alpha.1

package/shared/modules/dynamic/factories/base/useDetailsFactory.ts

@@ -1,145 +0,0 @@
-import { ComputedRef, MaybeRef, computed, ref, watch } from "vue";
-import * as _ from "lodash-es";
-import { useForm, useIsFormValid } from "vee-validate";
-import { useAsync } from "@core/composables/useAsync";
-import { useLoading } from "@core/composables/useLoading";
-import type { ItemId, IValidationState, UseDetails } from "@shared/modules/dynamic/factories/types";
-import { createUnrefFn } from "@vueuse/core";
-
-export interface UseDetailsFactoryParams<Item> {
-  load: (args?: ItemId) => Promise<Item | undefined> | Item | undefined;
-  saveChanges?: (details: Item) => Promise<Item | void> | Item | void;
-  remove?: (args: ItemId) => Promise<void> | void;
-}
-
-export const useDetailsFactory = <Item extends { id?: string }>(factoryParams: UseDetailsFactoryParams<Item>) => {
-  return function useDetails(): UseDetails<Item> {
-    const { setFieldError, setErrors, validate, setFieldValue, setValues, errorBag } = useForm({
-      validateOnMount: false,
-    });
-    const item = ref<Item>();
-    const itemTemp = ref<Item>();
-    const isModified = ref(false);
-    const isFormValid = useIsFormValid();
-    const isDisabled = computed(() => !isModified.value || !isFormValid.value);
-
-    const { loading: itemLoading, action: load } = useAsync<ItemId>(async (args?: ItemId) => {
-      const res = await factoryParams.load(args);
-
-      if (res) {
-        item.value = res;
-        item.value && resetModified(item.value);
-      }
-    });
-
-    const { loading: manageLoading, action: saveChanges } = useAsync<Item, Item | undefined>(async (itemToSave) => {
-      if (validationState.value.valid) {
-        const res = await factoryParams.saveChanges?.(itemToSave as Item);
-        isModified.value = false;
-
-        const id = itemToSave?.id ?? res?.id;
-
-        if (id) {
-          await load({ id });
-        }
-
-        if (res) return res;
-      } else throw new Error("Form is not valid");
-    });
-
-    const { loading: removeLoading, action: remove } = useAsync<ItemId | Item>(async (args) => {
-      await factoryParams.remove?.(args as ItemId);
-    });
-
-    const loading = useLoading(itemLoading, manageLoading, removeLoading);
-
-    const validationState = computed(
-      (): IValidationState<Item> => ({
-        /**
-         * @deprecated `dirty` - use `modified` instead
-         */
-        dirty: isModified.value,
-        valid: isFormValid.value,
-        modified: isModified.value,
-        disabled: isDisabled.value,
-        validated: !isDisabled.value && isModified.value,
-        cachedValue: itemTemp.value,
-        errorBag: errorBag.value,
-        setFieldError,
-        setErrors,
-        setFieldValue,
-        setValues,
-        resetModified,
-        resetValidationState,
-        validate,
-        setModifiedState,
-      }),
-    );
-
-    function setModifiedState(value: boolean) {
-      isModified.value = value;
-    }
-
-    function normalizeData(data: unknown): unknown {
-      if (
-        data === null ||
-        data === undefined ||
-        data === "" ||
-        (Array.isArray(data) && data.length === 0) ||
-        (typeof data === "object" && data !== null && Object.keys(data).length === 0)
-      ) {
-        return undefined;
-      }
-
-      if (Array.isArray(data)) {
-        return data.map((item) => normalizeData(item));
-      }
-
-      if (typeof data === "object") {
-        const normalizedObj: Record<string, unknown> = {};
-        for (const key in data) {
-          if (Object.prototype.hasOwnProperty.call(data, key)) {
-            normalizedObj[key] = normalizeData(data[key as keyof typeof data]);
-          }
-        }
-        return normalizedObj;
-      }
-
-      return data;
-    }
-
-    watch(
-      [() => item.value, () => itemTemp.value],
-      ([state, stateCopy]) => {
-        const normalizedState = normalizeData(state);
-        const normalizedStateCopy = normalizeData(stateCopy);
-
-        isModified.value = !_.isEqual(normalizedState, normalizedStateCopy);
-      },
-      { deep: true },
-    );
-
-    const resetModified = createUnrefFn((data: Item, updateInitial = false) => {
-      if (updateInitial) {
-        item.value = data;
-
-        resetValidationState();
-      }
-
-      itemTemp.value = _.cloneDeep(data);
-    }) as (data: MaybeRef<Item | undefined> | ComputedRef<Item | undefined>, updateInitial?: MaybeRef<boolean>) => void;
-
-    const resetValidationState = () => {
-      isModified.value = false;
-    };
-
-    return {
-      load,
-      saveChanges,
-      remove,
-      loading,
-      item,
-      validationState,
-    };
-  };
-};

package/shared/modules/dynamic/factories/base/useListFactory.ts

@@ -1,69 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Ref, computed, ref } from "vue";
-import { CustomQuery, UseList } from "@shared/modules/dynamic/factories/types";
-import { useAsync } from "@core/composables/useAsync";
-import { useLoading } from "@core/composables/useLoading";
-
-interface ISearchResult<T> {
-  totalCount?: number;
-  results?: T;
-}
-
-export interface UseListFactoryParams<Items extends Record<string, any>[], Query extends IQuery> {
-  load?: (query: Query, ...args: any[]) => Promise<ISearchResult<Items>> | ISearchResult<Items>;
-  remove?: (query: Query, customQuery: CustomQuery, ...args: any[]) => Promise<void> | void;
-}
-
-export interface IQuery {
-  [x: string]: any;
-  take?: number;
-  sort?: string;
-  skip?: number;
-  keyword?: string;
-}
-
-export interface IUseListOptions extends Pick<IQuery, "sort"> {
-  pageSize?: number;
-}
-
-export const useListFactory = <Items extends Record<string, any>[], Query extends IQuery>(
-  factoryParams: UseListFactoryParams<Items, Query>,
-) => {
-  return function useList(options?: IUseListOptions): UseList<Items, Query> {
-    const pageSize = options?.pageSize || 20;
-    const searchResult = ref<ISearchResult<Items>>();
-    const searchQuery = ref({
-      take: pageSize,
-      sort: options?.sort,
-    }) as Ref<Query>;
-
-    const { loading: itemsLoading, action: load } = useAsync<Query>(async (query, ...rest) => {
-      searchQuery.value = { ...searchQuery.value, ...query };
-      searchResult.value = await factoryParams.load?.(query as Query, ...rest);
-    });
-
-    const { loading: itemsDelete, action: remove } = useAsync<CustomQuery>(async (customQuery, ...rest) => {
-      await factoryParams.remove?.(searchQuery.value, customQuery as CustomQuery, ...rest);
-    });
-
-    const loading = useLoading(itemsLoading, itemsDelete);
-
-    const pagination = computed(() => ({
-      currentPage: (searchQuery.value?.skip || 0) / Math.max(1, searchQuery?.value.take || 20) + 1,
-      totalCount: searchResult.value?.totalCount || 0,
-      pageSize: pageSize,
-      get pages() {
-        return Math.ceil(this.totalCount / this.pageSize);
-      },
-    }));
-
-    return {
-      items: computed(() => searchResult.value?.results as Items),
-      query: searchQuery,
-      loading,
-      pagination,
-      load,
-      remove,
-    };
-  };
-};

package/shared/modules/dynamic/factories/index.ts

@@ -1,4 +0,0 @@
-export { useDetailsFactory } from "@shared/modules/dynamic/factories/base/useDetailsFactory";
-export { useListFactory } from "@shared/modules/dynamic/factories/base/useListFactory";
-
-export * from "@shared/modules/dynamic/factories/types";

package/shared/modules/dynamic/factories/types/index.ts

@@ -1,220 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ComputedRef, MaybeRef, Ref, UnwrapNestedRefs } from "vue";
-import { AsyncAction } from "@core/composables/useAsync";
-import { IUseDynamicProperties } from "@core/composables/useDynamicProperties";
-import { SettingsDetails, SettingsGrid, SettingsSchema } from "@shared/modules/dynamic/types";
-import type {
-  AssetsHandler,
-  IActionBuilderResult,
-  IBladeToolbar,
-  ICommonAsset,
-  ITableColumns,
-} from "@core/types";
-import { useBladeNavigation } from "@shared/components/blade-navigation/composables";
-import { FormContext } from "vee-validate";
-import { Breadcrumbs } from "@ui/types";
-import { DynamicBladeForm, DynamicBladeList } from "@shared/modules/dynamic/pages";
-
-export type ItemId = { id: string };
-
-export interface IPagination {
-  currentPage: number;
-  totalCount: number;
-  pageSize: number;
-  pages: number;
-}
-
-export interface IValidationState<Item> {
-  valid: boolean;
-  /**
-   * @deprecated `dirty` - use `modified` instead
-   */
-  dirty: boolean;
-  disabled: boolean;
-  modified: boolean;
-  validated: boolean;
-  cachedValue: Item | undefined;
-  setFieldError: FormContext["setFieldError"];
-  setFieldValue: FormContext["setFieldValue"];
-  setValues: FormContext["setValues"];
-  setErrors: FormContext["setErrors"];
-  resetModified: (
-    data: MaybeRef<Item | undefined> | ComputedRef<Item | undefined>,
-    updateInitial?: MaybeRef<boolean>,
-  ) => void;
-  resetValidationState: () => void;
-  validate: FormContext["validate"];
-  errorBag: Partial<Record<string, string[]>>;
-  setModifiedState: (value: boolean) => void;
-}
-
-export type CustomQuery = { ids: string[] | null; allSelected?: boolean };
-
-export interface UseDetails<Item, Scope extends DetailsBaseBladeScope = DetailsBaseBladeScope> {
-  load: AsyncAction<ItemId>;
-  saveChanges: AsyncAction<Item, Item | void>;
-  remove?: AsyncAction<ItemId | Item>;
-  loading: ComputedRef<boolean>;
-  item: Ref<Item | undefined>;
-  validationState: ComputedRef<IValidationState<Item>>;
-  scope?: Scope;
-  bladeTitle?: ComputedRef<string>;
-}
-
-export interface UseList<
-  Items extends Record<string, any>[],
-  Query,
-  Scope extends ListBaseBladeScope<Items[number]> = ListBaseBladeScope<Items[number]>,
-> {
-  items: ComputedRef<Items>;
-  query: Ref<Query>;
-  loading: ComputedRef<boolean>;
-  pagination: ComputedRef<{
-    currentPage: number;
-    totalCount: number;
-    pageSize: number;
-    pages: number;
-  }>;
-  load: AsyncAction<Query>;
-  remove?: AsyncAction<CustomQuery>;
-  scope?: Scope;
-}
-
-export interface ITableConfig {
-  loading?: boolean;
-  columns?: ITableColumns[];
-  stateKey?: string;
-  items?: Record<string, any>[];
-  multiselect?: boolean;
-  header?: boolean;
-  itemActionBuilder?: (item: Record<string, any>) => IActionBuilderResult[] | undefined;
-  editing?: boolean;
-  enableItemActions?: boolean;
-  footer?: boolean;
-  sort?: string;
-  pages?: number;
-  currentPage?: number;
-  searchValue?: string;
-  selectedItemId?: string | undefined;
-  totalCount?: number;
-  reorderableRows?: boolean;
-  pullToReload?: boolean;
-  selectAll?: boolean;
-  paginationVariant?: "default" | "minimal" | undefined;
-  selectionItems?: Record<string, any>[];
-  onItemClick?: (item: Record<string, any>) => void;
-  onPaginationClick?: (page: number) => void;
-  onSelectionChanged?: (items: Record<string, any>[]) => void;
-  onHeaderClick?: (item: ITableColumns) => void;
-  "onScroll:ptr"?: () => void;
-  "onSearch:change"?: (keyword: string | undefined) => void;
-  "onRow:reorder"?: (event: { dragIndex: number; dropIndex: number; value: any[] }) => void;
-  "onSelect:all"?: (all: boolean) => void;
-  onEditComplete?: (data: { event: { field: string; value: any }; index: number }) => void;
-  onCellBlur?: (data: { row: number | undefined; field: string }) => void;
-  disableItemCheckbox?: (item: Record<string, any> | undefined) => boolean;
-  columnSelector?: "auto" | "defined" | MaybeRef<ITableColumns[]> | (() => ITableColumns[]);
-}
-
-export interface BaseBladeScope {
-  [x: string]: any;
-  toolbarOverrides?:
-    | MaybeRef<{ [x: string]: IBladeToolbar | IBladeToolbar[] | MaybeRef<IBladeToolbar> | MaybeRef<IBladeToolbar[]> }>
-    | ((...args: any[]) => any)
-    | MaybeRef<IBladeToolbar[]>;
-}
-
-export interface ListBaseBladeScope<Item = Record<string, any>, Query = Record<string, any>> extends BaseBladeScope {
-  openDetailsBlade?: (
-    args?: Omit<Parameters<ReturnType<typeof useBladeNavigation>["openBlade"]>["0"], "blade">,
-  ) => Promise<void> | void;
-  onListItemClick?: (
-    args: { item?: Item } & Omit<
-      Parameters<ReturnType<typeof useBladeNavigation>["openBlade"]>["0"],
-      "blade" | "param" | "options"
-    >,
-  ) => void;
-  onPaginationClick?: (query: Query) => void;
-  breadcrumbs?: ComputedRef<Breadcrumbs[]>;
-  modified?: ComputedRef<boolean> | Ref<boolean> | boolean;
-  tableConfig?: (initialTableConfig: ITableConfig) => ITableConfig;
-}
-
-export type TOpenBladeArgs = Omit<Parameters<ReturnType<typeof useBladeNavigation>["openBlade"]>["0"], "blade">;
-export type TListItemClickArgs<Item extends Record<string, any> = Record<string, any>> = Omit<
-  Parameters<ReturnType<typeof useBladeNavigation>["openBlade"]>["0"],
-  "blade" | "param" | "options"
-> & { item?: Item | undefined };
-
-export interface DetailsBaseBladeScope<Item = Record<string, any>> extends BaseBladeScope {
-  disabled?: ComputedRef<boolean | undefined> | Ref<boolean | undefined> | boolean;
-  multilanguage?: {
-    loading: ComputedRef<boolean>;
-    currentLocale: Ref<string>;
-    languages: Ref<string[]>;
-    setLocale: (locale: string) => void;
-    localesOptions: Ref<{ label: string | undefined; value: string }[]>;
-    getLanguages: AsyncAction<void, void>;
-  };
-  dynamicProperties?: IUseDynamicProperties<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >;
-  assetsHandler?: {
-    assets?: AssetsHandler<ICommonAsset>;
-    images?: AssetsHandler<ICommonAsset>;
-  };
-  selection?: Item[];
-}
-
-export interface DetailsBladeContext<
-  Item extends Record<string, any> = Record<string, any>,
-  Scope extends DetailsBaseBladeScope = DetailsBaseBladeScope,
-> extends UseDetails<Item, Scope> {
-  settings: ComputedRef<SettingsSchema>;
-}
-
-export interface ListBladeContext<
-  Items extends Record<string, any>[] = Record<string, any>[],
-  Query = Record<string, any>,
-  Scope extends ListBaseBladeScope = ListBaseBladeScope,
-> extends UseList<Items, Query, Scope> {
-  settings: ComputedRef<SettingsSchema>;
-  selectedIds: ComputedRef<string[]>;
-}
-
-export interface BaseBladeExposed {
-  updateActiveWidgetCount: () => void;
-  readonly title: MaybeRef<string>;
-}
-
-export type ListBladeExposed<Scope extends ListBaseBladeScope> = BaseBladeExposed & {
-  readonly selectedIds: string[];
-  reload: () => void;
-  readonly settings: SettingsGrid;
-} & UnwrapNestedRefs<Scope>;
-
-export type DetailsBladeExposed<Scope extends DetailsBaseBladeScope> = BaseBladeExposed & {
-  readonly settings: SettingsDetails;
-  readonly item: Record<string, any>;
-  readonly validationState: IValidationState<Record<string, any>>;
-} & UnwrapNestedRefs<Scope>;
-
-export type DetailsComposableArgs<
-  Props extends Omit<InstanceType<typeof DynamicBladeForm>["$props"], "composables"> = Record<string, any>,
-> = {
-  props: InstanceType<typeof DynamicBladeForm>["$props"] & Props;
-  emit: InstanceType<typeof DynamicBladeForm>["$emit"];
-  mounted: Ref<boolean>;
-};
-
-export type ListComposableArgs<
-  Props extends Omit<InstanceType<typeof DynamicBladeList>["$props"], "composables"> = Record<string, any>,
-> = {
-  readonly props: InstanceType<typeof DynamicBladeList>["$props"] & Props;
-  readonly emit: InstanceType<typeof DynamicBladeList>["$emit"];
-  readonly mounted: Ref<boolean>;
-};

package/shared/modules/dynamic/helpers/getters.ts

@@ -1,12 +0,0 @@
-import * as _ from "lodash-es";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const getModel = (property: string, context: Record<string, any>) => {
-  if (property && context) {
-    if (typeof context[property] === "function") {
-      return context[property]();
-    }
-    return _.get(context, property);
-  }
-  return null;
-};

package/shared/modules/dynamic/helpers/methodHandler.ts

@@ -1,22 +0,0 @@
-import { ControlSchema } from "@shared/modules/dynamic/types";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ComputedRef, toValue } from "vue";
-
-export const methodHandler = (
-  visibility:
-    | ComputedRef<boolean | undefined>
-    | ((schema: ControlSchema, fieldContext: Record<string, any> | undefined) => boolean)
-    | undefined,
-  fieldContext: Record<string, any> | undefined,
-  schema: ControlSchema,
-) => {
-  if (visibility === undefined) {
-    return true;
-  }
-
-  if (typeof visibility === "function") {
-    return visibility(schema, fieldContext);
-  }
-
-  return toValue(visibility);
-};