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

package/core/composables/useDynamicProperties/index.ts

@@ -1,573 +0,0 @@
-import { useLoading } from "@core/composables/useLoading";
-import { useAsync } from "@core/composables/useAsync";
-import { ComputedRef } from "vue";
-
-// === TYPE DEFINITIONS ===
-
-export interface IBaseProperty<TPropertyValue> {
-  id?: string | null;
-  name?: string | null;
-  values?: TPropertyValue[] | null;
-  multilanguage?: boolean | null;
-  multivalue?: boolean | null;
-  dictionary?: boolean | null;
-  valueType?: string | null;
-}
-
-export interface IBasePropertyValue {
-  propertyName?: string | null;
-  propertyId?: string | null;
-  languageCode?: string | null;
-  alias?: string | null;
-  valueType?: string | null;
-  value?: any; // eslint-disable-line @typescript-eslint/no-explicit-any
-  valueId?: string | null;
-  isInherited?: boolean;
-  unitOfMeasureId?: string | null;
-  colorCode?: string | null;
-}
-
-export interface IBasePropertyDictionaryItem {
-  id?: string | null;
-  propertyId?: string | null;
-  alias?: string | null;
-  localizedValues?: { languageCode?: string | null; value?: string | null }[] | null;
-  value?: string;
-  colorCode?: string | null;
-}
-
-export interface IBasePropertyDictionaryItemSearchCriteria {
-  propertyIds?: string[] | null;
-  keyword?: string | null;
-  skip?: number | null;
-  take?: number | null;
-}
-
-export interface IBaseMeasurementDictionaryItem {
-  code?: string | null;
-  name?: string | null;
-  symbol?: string | null;
-  isDefault?: boolean;
-  id?: string | null;
-}
-
-export interface IUseDynamicProperties<
-  TProperty extends IBaseProperty<TPropertyValue>,
-  TPropertyValue extends IBasePropertyValue,
-  TPropertyDictionaryItem extends IBasePropertyDictionaryItem,
-  TPropertyDictionaryItemSearchCriteria extends IBasePropertyDictionaryItemSearchCriteria,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  TMeasurement extends IBaseMeasurementDictionaryItem = Record<string, any>,
-> {
-  loading: ComputedRef<boolean>;
-  loadDictionaries: (
-    propertyId: string,
-    keyword?: string,
-    locale?: string,
-  ) => Promise<TPropertyDictionaryItem[] | undefined>;
-  getPropertyValue: (
-    property: TProperty,
-    locale: string,
-  ) => string | TPropertyValue[] | boolean | (TPropertyDictionaryItem & { value: string })[];
-  setPropertyValue: (data: SetPropertyValueParams<TProperty, TPropertyValue, TPropertyDictionaryItem>) => void;
-  loadMeasurements(measureId: string, keyword?: string, locale?: string): Promise<TMeasurement[] | undefined>;
-}
-
-export interface SetPropertyValueParams<TProperty, TPropertyValue, TPropertyDictionaryItem> {
-  property: TProperty;
-  value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[];
-  dictionary?: TPropertyDictionaryItem[];
-  locale?: string;
-  initialProp?: TProperty;
-  unitOfMeasureId?: string;
-  colorCode?: string;
-}
-
-// === UTILITY FUNCTIONS ===
-
-function isEmptyValue(value: unknown): boolean {
-  if (value === undefined || value === null) return true;
-  if (typeof value === "number" && isNaN(value)) return true;
-  if (typeof value === "string" && value.trim().length === 0) return true;
-  if (typeof value === "object" && Object.keys(value).length === 0) return true;
-  return false;
-}
-
-function isMultilanguageProperty<T extends IBaseProperty<unknown>>(property: T): boolean {
-  return Boolean(property.multilanguage);
-}
-
-function isMultivalueProperty<T extends IBaseProperty<unknown>>(property: T): boolean {
-  return Boolean(property.multivalue);
-}
-
-function isDictionaryProperty<T extends IBaseProperty<unknown>>(property: T): boolean {
-  return Boolean(property.dictionary);
-}
-
-function isMeasureProperty<T extends IBaseProperty<unknown>>(property: T): boolean {
-  return property.valueType === "Measure";
-}
-
-function isColorProperty<T extends IBaseProperty<unknown>>(property: T): boolean {
-  return property.valueType === "Color";
-}
-
-// === MAIN COMPOSABLE ===
-
-export const useDynamicProperties = <
-  TProperty extends IBaseProperty<TPropertyValue>,
-  TPropertyValue extends IBasePropertyValue,
-  TPropertyDictionaryItem extends IBasePropertyDictionaryItem,
-  TPropertyDictionaryItemSearchCriteria extends IBasePropertyDictionaryItemSearchCriteria,
-  TMeasurement extends IBaseMeasurementDictionaryItem,
->(
-  searchDictionaryItemsFunction: (
-    criteria: TPropertyDictionaryItemSearchCriteria,
-  ) => Promise<TPropertyDictionaryItem[] | undefined>,
-  PropertyValueConstructor: new (data?: Partial<TPropertyValue>) => TPropertyValue,
-  PropertyDictionaryItemConstructor: new (data?: Partial<TPropertyDictionaryItem>) => TPropertyDictionaryItem,
-  searchMeasurementFunction?: (measureId: string, locale?: string) => Promise<TMeasurement[] | undefined>,
-): IUseDynamicProperties<TProperty, TPropertyValue, TPropertyDictionaryItem, TPropertyDictionaryItemSearchCriteria> => {
-  // === ASYNC OPERATIONS ===
-
-  const { loading: dictionaryItemsLoading, action: searchDictionaryItems } = useAsync<
-    TPropertyDictionaryItemSearchCriteria,
-    TPropertyDictionaryItem[] | undefined
-  >(async (args: TPropertyDictionaryItemSearchCriteria | undefined) => {
-    if (!args) return undefined;
-    return await searchDictionaryItemsFunction(args);
-  });
-
-  async function loadDictionaries(propertyId: string, keyword?: string, locale?: string) {
-    if (!propertyId) return undefined;
-
-    const dictionaryItems = await searchDictionaryItems({
-      propertyIds: [propertyId],
-      keyword,
-      skip: 0,
-    } as TPropertyDictionaryItemSearchCriteria);
-
-    if (!locale || !dictionaryItems) return dictionaryItems;
-
-    return dictionaryItems.map((item: TPropertyDictionaryItem) => {
-      const localizedValue = item.localizedValues?.find((localized) => localized.languageCode === locale)?.value;
-
-      return Object.assign(new PropertyDictionaryItemConstructor(item), {
-        value: localizedValue ?? item.alias,
-      });
-    });
-  }
-
-  async function loadMeasurements(measureId: string, locale?: string) {
-    if (!measureId || !searchMeasurementFunction) return undefined;
-    return await searchMeasurementFunction(measureId, locale);
-  }
-
-  // === VALUE GETTERS ===
-
-  function getMultilanguageValue(property: TProperty, locale: string): string | TPropertyValue[] | boolean {
-    const valueForLocale = property.values?.find((x) => x.languageCode === locale);
-
-    if (isMultivalueProperty(property)) {
-      return property.values?.filter((x) => x.languageCode === locale) as TPropertyValue[];
-    }
-
-    // Create default value if not exists
-    if (!valueForLocale) {
-      const aliasValue = property.values?.find((x) => x.propertyId === property.id);
-      if (aliasValue) {
-        const newValue = new PropertyValueConstructor({
-          propertyName: property.name,
-          propertyId: property.id,
-          languageCode: locale,
-          alias: aliasValue.alias,
-          valueType: property.valueType,
-          valueId: aliasValue.valueId,
-        } as unknown as Partial<TPropertyValue>);
-
-        property.values?.push(newValue);
-      }
-      // For boolean properties, return false if no value exists
-      if (property.valueType === "Boolean") {
-        return false;
-      }
-    }
-
-    if (isDictionaryProperty(property)) {
-      return valueForLocale?.valueId as string;
-    }
-
-    return valueForLocale?.value as string;
-  }
-
-  function getSingleLanguageValue(property: TProperty): string | TPropertyValue[] | boolean {
-    if (isMultivalueProperty(property)) {
-      return property.values as TPropertyValue[];
-    }
-
-    const firstValue = property.values?.[0];
-    if (!firstValue) {
-      // For boolean properties, return false instead of empty string
-      if (property.valueType === "Boolean") {
-        return false;
-      }
-      return "";
-    }
-
-    if (isDictionaryProperty(property)) {
-      return firstValue.valueId as string;
-    }
-
-    return firstValue.value as string;
-  }
-
-  function getPropertyValue(property: TProperty, locale: string): string | TPropertyValue[] | boolean {
-    if (isMultilanguageProperty(property)) {
-      return getMultilanguageValue(property, locale);
-    }
-    return getSingleLanguageValue(property);
-  }
-
-  // === VALUE SETTERS ===
-
-  function createPropertyValue(params: Partial<TPropertyValue>): TPropertyValue {
-    return new PropertyValueConstructor({
-      isInherited: false,
-      ...params,
-    } as unknown as Partial<TPropertyValue>);
-  }
-
-  function setMeasurePropertyValue(property: TProperty, value: unknown, unitOfMeasureId?: string): void {
-    property.values = [
-      createPropertyValue({
-        value,
-        unitOfMeasureId,
-      } as Partial<TPropertyValue>),
-    ];
-  }
-
-  function setColorPropertyValue(property: TProperty, value: unknown, colorCode?: string): void {
-    // Handle multivalue array
-    if (Array.isArray(value)) {
-      property.values = (value as TPropertyValue[]).map((item) =>
-        createPropertyValue({
-          ...item,
-          value: item.value,
-          colorCode: item.colorCode,
-        } as Partial<TPropertyValue>),
-      );
-    } else {
-      // Handle single value
-      property.values = [
-        createPropertyValue({
-          value,
-          colorCode,
-        } as Partial<TPropertyValue>),
-      ];
-    }
-  }
-
-  function setDictionaryPropertyValue(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    dictionary: TPropertyDictionaryItem[],
-    locale?: string,
-  ): void {
-    const dict = dictionary.map((x) => new PropertyDictionaryItemConstructor(x));
-
-    if (isMultilanguageProperty(property)) {
-      handleMultilanguageDictionary(property, value, dict, locale);
-    } else {
-      handleSingleLanguageDictionary(property, value, dict);
-    }
-  }
-
-  function handleMultilanguageDictionary(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    dict: TPropertyDictionaryItem[],
-    locale?: string,
-  ): void {
-    if (Array.isArray(value)) {
-      handleMultilanguageMultivalueDictionary(property, value as (TPropertyDictionaryItem & { value: string })[], dict);
-    } else {
-      handleMultilanguageSingleValueDictionary(property, value as string, dict, locale);
-    }
-  }
-
-  function handleMultilanguageMultivalueDictionary(
-    property: TProperty,
-    values: (TPropertyDictionaryItem & { value: string })[],
-    dict: TPropertyDictionaryItem[],
-  ): void {
-    property.values = values.flatMap((item) => {
-      const dictItem = dict.find((x) => x.id === (item as unknown as TPropertyValue).valueId || x.id === item.id);
-
-      if (dictItem?.localizedValues?.length) {
-        return dictItem.localizedValues.map((locValue) =>
-          createPropertyValue({
-            propertyId: dictItem.propertyId,
-            alias: dictItem.alias,
-            languageCode: locValue.languageCode,
-            value: locValue.value ?? dictItem.alias,
-            valueId: dictItem.id,
-            colorCode: dictItem.colorCode,
-          } as Partial<TPropertyValue>),
-        );
-      }
-
-      return createPropertyValue(item as unknown as Partial<TPropertyValue>);
-    });
-  }
-
-  function handleMultilanguageSingleValueDictionary(
-    property: TProperty,
-    value: string,
-    dict: TPropertyDictionaryItem[],
-    locale?: string,
-  ): void {
-    const dictionaryItem = dict.find((x) => x.id === value);
-
-    if (!dictionaryItem) {
-      property.values = [];
-      return;
-    }
-
-    if (dictionaryItem.localizedValues?.length) {
-      property.values = dictionaryItem.localizedValues.map((locValue) =>
-        createPropertyValue({
-          propertyId: dictionaryItem.propertyId,
-          alias: dictionaryItem.alias,
-          languageCode: locValue.languageCode,
-          value: locValue.value ?? dictionaryItem.alias,
-          valueId: dictionaryItem.id,
-          colorCode: dictionaryItem.colorCode,
-        } as Partial<TPropertyValue>),
-      );
-    } else {
-      // Fallback: localizedValues is missing or empty (e.g. improperly created on platform side).
-      // Use existing language codes from property.values, or fall back to current locale.
-      const existingLanguageCodes = [
-        ...new Set((property.values ?? []).map((v) => v.languageCode).filter(Boolean)),
-      ];
-      const languageCodes = existingLanguageCodes.length > 0 ? existingLanguageCodes : locale ? [locale] : [];
-
-      property.values = languageCodes.map((langCode) =>
-        createPropertyValue({
-          propertyId: dictionaryItem.propertyId,
-          alias: dictionaryItem.alias,
-          languageCode: langCode,
-          value: dictionaryItem.alias,
-          valueId: dictionaryItem.id,
-          colorCode: dictionaryItem.colorCode,
-        } as Partial<TPropertyValue>),
-      );
-    }
-  }
-
-  function handleSingleLanguageDictionary(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    dict: TPropertyDictionaryItem[],
-  ): void {
-    if (Array.isArray(value)) {
-      handleSingleLanguageMultivalueDictionary(
-        property,
-        value as (TPropertyDictionaryItem & { value: string })[],
-        dict,
-      );
-    } else {
-      handleSingleLanguageSingleValueDictionary(property, value as string, dict);
-    }
-  }
-
-  function handleSingleLanguageMultivalueDictionary(
-    property: TProperty,
-    values: (TPropertyDictionaryItem & { value: string })[],
-    dict: TPropertyDictionaryItem[],
-  ): void {
-    property.values = values.flatMap((item) => {
-      const dictItem = dict.find((x) => x.id === (item as unknown as TPropertyValue).valueId || x.id === item.id);
-
-      if (dictItem) {
-        return createPropertyValue({
-          propertyId: dictItem.propertyId,
-          alias: dictItem.alias,
-          value: item.value ?? dictItem.alias,
-          valueId: dictItem.id,
-          colorCode: dictItem.colorCode,
-        } as Partial<TPropertyValue>);
-      }
-
-      return createPropertyValue(item as unknown as Partial<TPropertyValue>);
-    });
-  }
-
-  function handleSingleLanguageSingleValueDictionary(
-    property: TProperty,
-    value: string,
-    dict: TPropertyDictionaryItem[],
-  ): void {
-    if (isEmptyValue(value)) {
-      property.values = [];
-      return;
-    }
-
-    const dictionaryItem = dict.find((x) => x.id === value);
-    property.values = [
-      createPropertyValue({
-        propertyId: dictionaryItem?.propertyId,
-        alias: dictionaryItem?.alias,
-        value: (dictionaryItem as TPropertyDictionaryItem & { value: string })?.value ?? dictionaryItem?.alias,
-        valueId: value,
-        colorCode: dictionaryItem?.colorCode,
-      } as Partial<TPropertyValue>),
-    ];
-  }
-
-  function setRegularPropertyValue(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    locale?: string,
-    initialProp?: TProperty,
-  ): void {
-    if (isMultilanguageProperty(property)) {
-      handleMultilanguageRegularProperty(property, value, locale);
-    } else {
-      handleSingleLanguageRegularProperty(property, value, locale, initialProp);
-    }
-  }
-
-  function handleMultilanguageRegularProperty(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    locale?: string,
-  ): void {
-    if (Array.isArray(value)) {
-      // Multivalue multilanguage
-      property.values =
-        property.values &&
-        ([
-          ...property.values.filter((x) => x.languageCode !== locale),
-          ...(value as TPropertyValue[]).map((item) =>
-            createPropertyValue({ ...item, languageCode: locale } as Partial<TPropertyValue>),
-          ),
-        ] as TPropertyValue[]);
-    } else {
-      // Single value multilanguage
-      const existingValue = property.values?.find((x) => x.languageCode === locale);
-      if (existingValue) {
-        existingValue.value = value as string;
-      } else {
-        property.values = [
-          createPropertyValue({
-            value: value as string,
-            languageCode: locale,
-          } as Partial<TPropertyValue>),
-        ];
-      }
-    }
-  }
-
-  function handleSingleLanguageRegularProperty(
-    property: TProperty,
-    value: string | TPropertyValue[] | (TPropertyDictionaryItem & { value: string })[],
-    locale?: string,
-    initialProp?: TProperty,
-  ): void {
-    if (Array.isArray(value)) {
-      // Multivalue
-      property.values = (value as TPropertyValue[]).map((item) => createPropertyValue(item as Partial<TPropertyValue>));
-    } else {
-      handleSingleValueRegularProperty(property, value, locale, initialProp);
-    }
-  }
-
-  function handleSingleValueRegularProperty(
-    property: TProperty,
-    value: string | (TPropertyDictionaryItem & { value: string }),
-    locale?: string,
-    initialProp?: TProperty,
-  ): void {
-    if (typeof value === "boolean") {
-      handleBooleanValue(property, value, initialProp);
-    } else if (isEmptyValue(value)) {
-      handleEmptyValue(property, value, locale, initialProp);
-    } else {
-      handleNonEmptyValue(property, value as string);
-    }
-  }
-
-  function handleBooleanValue(property: TProperty, value: boolean, initialProp?: TProperty): void {
-    // Always create or update the value, even if it's false
-    // This ensures the state is properly reflected in the UI
-    if (property.values?.[0]) {
-      Object.assign(property.values[0], { value });
-    } else {
-      property.values = [createPropertyValue({ value } as Partial<TPropertyValue>)];
-    }
-  }
-
-  function handleEmptyValue(property: TProperty, value: unknown, locale?: string, initialProp?: TProperty): void {
-    const hadOriginalValue = initialProp?.values?.find((v) =>
-      isMultilanguageProperty(property) ? v.languageCode === locale : true,
-    )?.value;
-
-    const originalWasEmpty = isEmptyValue(hadOriginalValue);
-
-    if (originalWasEmpty) {
-      property.values = [
-        createPropertyValue({
-          value: value as string,
-          languageCode: isMultilanguageProperty(property) ? locale : undefined,
-        } as Partial<TPropertyValue>),
-      ];
-    } else {
-      property.values = [];
-    }
-  }
-
-  function handleNonEmptyValue(property: TProperty, value: string): void {
-    if (property.values?.[0]) {
-      Object.assign(property.values[0], { value });
-    } else {
-      property.values = [createPropertyValue({ value } as Partial<TPropertyValue>)];
-    }
-  }
-
-  // === MAIN SET PROPERTY VALUE FUNCTION ===
-
-  function setPropertyValue(params: SetPropertyValueParams<TProperty, TPropertyValue, TPropertyDictionaryItem>): void {
-    const { property, value, dictionary, locale, initialProp, unitOfMeasureId, colorCode } = params;
-
-    if (isMeasureProperty(property)) {
-      setMeasurePropertyValue(property, value, unitOfMeasureId);
-      return;
-    }
-
-    if (isColorProperty(property) && !dictionary?.length) {
-      setColorPropertyValue(property, value, colorCode);
-      return;
-    }
-
-    if (dictionary?.length) {
-      setDictionaryPropertyValue(property, value, dictionary, locale);
-      return;
-    }
-
-    setRegularPropertyValue(property, value, locale, initialProp);
-  }
-
-  // === RETURN API ===
-
-  const loading = useLoading(dictionaryItemsLoading);
-
-  return {
-    loading,
-    loadDictionaries,
-    getPropertyValue,
-    setPropertyValue,
-    loadMeasurements,
-  };
-};

package/core/composables/useErrorHandler/index.ts

@@ -1,75 +0,0 @@
-import { onErrorCaptured, getCurrentInstance, ref, Ref, nextTick } from "vue";
-import { useAppInsights } from "..";
-import { useUserManagement } from "@core/composables/useUserManagement";
-import { DisplayableError, parseError } from "@core/utilities/error";
-import { createLogger } from "@core/utilities";
-
-const logger = createLogger("use-error-handler");
-
-interface IUseErrorHandler {
-  error: Ref<DisplayableError | null>;
-  reset(): void;
-}
-
-/**
- * A composable to handle and normalize errors within a component's lifecycle.
- * It captures errors, tracks them with Application Insights, and emits them
- * for parent components to handle.
- *
- * @param capture - If true, prevents the error from propagating further up the component tree.
- * @returns An object with the reactive error and a reset function.
- */
-export function useErrorHandler(capture?: boolean): IUseErrorHandler {
-  const error = ref<DisplayableError | null>(null);
-  const instance = getCurrentInstance();
-  const { appInsights } = useAppInsights();
-  const { user } = useUserManagement();
-  const isProcessing = ref(false);
-
-  function reset() {
-    error.value = null;
-
-    if (instance) {
-      instance.emit("reset");
-    }
-  }
-
-  onErrorCaptured((err: unknown) => {
-    if (isProcessing.value) {
-      return !capture;
-    }
-
-    isProcessing.value = true;
-
-    const capturedError = parseError(err);
-    error.value = capturedError;
-
-    if (appInsights) {
-      appInsights.trackException({
-        exception: capturedError,
-        properties: {
-          userId: user.value?.id ?? "",
-          userName: user.value?.userName ?? "",
-        },
-      });
-    }
-
-    logger.error("Captured Error:", capturedError.originalError);
-
-    if (instance) {
-      instance.emit("error", capturedError);
-    }
-
-    nextTick(() => {
-      isProcessing.value = false;
-    });
-
-    // if `capture` is true, stop the error from propagating further.
-    return !capture;
-  });
-
-  return {
-    error,
-    reset,
-  };
-}

package/core/composables/useFunctions/debounce.ts

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export default function debounce(func: (...args: any[]) => void, delay: number): (...args: unknown[]) => void {
-  let timer: number | null = null;
-
-  return function (...args: unknown[]): void {
-    if (timer) {
-      clearTimeout(timer);
-    }
-
-    timer = window.setTimeout(() => {
-      timer = null;
-      func(...args);
-    }, delay);
-  };
-}

package/core/composables/useFunctions/delay.ts

@@ -1,3 +0,0 @@
-export default function delay(func: (...args: unknown[]) => void, delay = 0): void {
-  setTimeout(func, delay);
-}

package/core/composables/useFunctions/index.ts

@@ -1,20 +0,0 @@
-import debounce from "@core/composables/useFunctions/debounce";
-import delay from "@core/composables/useFunctions/delay";
-import once from "@core/composables/useFunctions/once";
-import throttle from "@core/composables/useFunctions/throttle";
-
-interface IUseFunctions {
-  debounce: typeof debounce;
-  delay: typeof delay;
-  once: typeof once;
-  throttle: typeof throttle;
-}
-
-export function useFunctions(): IUseFunctions {
-  return {
-    debounce,
-    delay,
-    once,
-    throttle,
-  };
-}

package/core/composables/useFunctions/once.ts

@@ -1,11 +0,0 @@
-const resultsMap = new WeakMap();
-
-export default function once(func: (...args: unknown[]) => void): (...args: unknown[]) => unknown {
-  return function (...args: unknown[]): unknown {
-    if (!resultsMap.has(func)) {
-      const result = func(...args);
-      resultsMap.set(func, result);
-    }
-    return resultsMap.get(func);
-  };
-}

package/core/composables/useFunctions/sleep.ts

@@ -1,3 +0,0 @@
-export default function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}