@webitel/ui-datalist 1.1.5 → 1.1.6

package/package.json

@@ -1,11 +1,11 @@
 {
 	"name": "@webitel/ui-datalist",
-	"version": "1.1.5",
+	"version": "1.1.6",
 	"description": "Toolkit for building data lists in webitel ui system",
 	"scripts": {
 		"make-all": "npm version patch --git-tag-version false && ( npm run lint:fix || true) && (npm run build:types || true) && npm run utils:publish",
 		"build:types": "vue-tsc -p ./tsconfig.build.json",
-		"lint:fix": "eslint --fix ./src && prettier --write --check ./src",
+		"lint:fix": "npx biome check --write ./src",
 		"lint:fix-staged": "npx lint-staged",
 		"lint:package": "publint",
 		"utils:i": "npm i",
@@ -41,24 +41,17 @@
 		"zod": "^4.x"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.22.0",
+		"@biomejs/biome": "2.3.14",
 		"@standard-schema/spec": "^1.x",
 		"@tsconfig/node22": "^22.0.0",
 		"@types/node": "^24.x",
 		"@vue/tsconfig": "^0.8.x",
-		"eslint": "^9.22.0",
-		"eslint-config-prettier": "^10.1.1",
-		"eslint-plugin-simple-import-sort": "^12.1.1",
-		"eslint-plugin-vue": "^10.0.0",
 		"globals": "^17.x",
 		"globby": "^16.x",
 		"lint-staged": "^16.x",
-		"prettier": "^3.5.3",
-		"prettier-plugin-css-order": "^2.1.2",
 		"publint": "^0.3.9",
 		"sass": "^1.85.1",
 		"typescript": "5.9.x",
-		"typescript-eslint": "^8.26.1",
 		"typescript-plugin-css-modules": "^5.x",
 		"unplugin-auto-import": "^19.x",
 		"vue-tsc": "^3.x"

package/src/modules/_shared/createDatalistStore.ts

@@ -1,22 +1,22 @@
 import {
-  defineStore as definePiniaStore,
-  StoreGeneric,
-  storeToRefs as piniaStoreToRefs,
+	defineStore as definePiniaStore,
+	storeToRefs as piniaStoreToRefs,
+	StoreGeneric,
 } from 'pinia';
-import { ToRefs, toRefs as composableStoreToRefs } from 'vue';
+import { toRefs as composableStoreToRefs, ToRefs } from 'vue';
 
 import { applyStorePatch } from '../scripts/utils';
 import {
-  CreateDatalistStoreParams,
-  Identifiable,
-  Patch,
-  PatchableStore,
-  PatchableStoreFactory,
-  StoreInstance,
+	CreateDatalistStoreParams,
+	Identifiable,
+	Patch,
+	PatchableStore,
+	PatchableStoreFactory,
+	StoreInstance,
 } from '../types/createDatalistStore.types';
 import {
-  DatalistStoreProvider,
-  DatalistStoreProviderType,
+	DatalistStoreProvider,
+	DatalistStoreProviderType,
 } from '../types/StoreProvider';
 
 const defaultStoreType = DatalistStoreProvider.Pinia;
@@ -26,48 +26,48 @@ const defaultStoreType = DatalistStoreProvider.Pinia;
  * using Pinia's storeToRefs if it's a Pinia store, or Vue's toRefs for composable stores.
  * */
 export const makeThisToRefs = <StoreBody extends object>(
-  store: StoreBody,
-  storeType: DatalistStoreProviderType,
+	store: StoreBody,
+	storeType: DatalistStoreProviderType,
 ): ToRefs<StoreBody> => {
-  const thisStoreType = storeType || defaultStoreType;
+	const thisStoreType = storeType || defaultStoreType;
 
-  if (thisStoreType === DatalistStoreProvider.Pinia) {
-    return piniaStoreToRefs(store as StoreGeneric) as ToRefs<StoreBody>;
-  }
+	if (thisStoreType === DatalistStoreProvider.Pinia) {
+		return piniaStoreToRefs(store as StoreGeneric) as ToRefs<StoreBody>;
+	}
 
-  return composableStoreToRefs(store) as ToRefs<StoreBody>;
+	return composableStoreToRefs(store) as ToRefs<StoreBody>;
 };
 
 export const createDatalistStore = <
-  StoreBody extends StoreInstance,
-  G extends Identifiable,
+	StoreBody extends StoreInstance,
+	G extends Identifiable,
 >({
-  config,
-  namespace,
-  storeBody,
+	config,
+	namespace,
+	storeBody,
 }: CreateDatalistStoreParams<
-  StoreBody,
-  G
+	StoreBody,
+	G
 >): PatchableStoreFactory<StoreBody> => {
-  const thisStoreType = config.storeType || defaultStoreType;
+	const thisStoreType = config.storeType || defaultStoreType;
 
-  if (thisStoreType === DatalistStoreProvider.Composable) {
-    const storeFactory = storeBody({
-      ...config,
-      storeType: thisStoreType,
-    }) as PatchableStore<StoreBody>;
-    storeFactory.$patch = (val: Patch) => applyStorePatch(storeFactory, val);
-    return () => storeFactory;
-  }
+	if (thisStoreType === DatalistStoreProvider.Composable) {
+		const storeFactory = storeBody({
+			...config,
+			storeType: thisStoreType,
+		}) as PatchableStore<StoreBody>;
+		storeFactory.$patch = (val: Patch) => applyStorePatch(storeFactory, val);
+		return () => storeFactory;
+	}
 
-  if (thisStoreType === DatalistStoreProvider.Pinia) {
-    return definePiniaStore(namespace, () =>
-      storeBody({
-        ...config,
-        storeType: thisStoreType,
-      }),
-    );
-  }
+	if (thisStoreType === DatalistStoreProvider.Pinia) {
+		return definePiniaStore(namespace, () =>
+			storeBody({
+				...config,
+				storeType: thisStoreType,
+			}),
+		);
+	}
 
-  throw new Error(`Unsupported store type: ${thisStoreType}`);
+	throw new Error(`Unsupported store type: ${thisStoreType}`);
 };

package/src/modules/card/composables/useCardAnyFieldEditedWatcher.ts

@@ -1,22 +1,22 @@
 import { ref, watch } from 'vue';
 
 export const useCardAnyFieldEditedWatcher = ({ value }) => {
-  const isAnyFieldEdited = ref(false);
+	const isAnyFieldEdited = ref(false);
 
-  let prevValue: object;
+	let prevValue: object;
 
-  watch(
-    value,
-    () => {
-      isAnyFieldEdited.value = prevValue === value.value; // if object value ref changes, object was overwritten completely
-      prevValue = value.value;
-    },
-    {
-      deep: true,
-    },
-  );
+	watch(
+		value,
+		() => {
+			isAnyFieldEdited.value = prevValue === value.value; // if object value ref changes, object was overwritten completely
+			prevValue = value.value;
+		},
+		{
+			deep: true,
+		},
+	);
 
-  return {
-    isAnyFieldEdited,
-  };
+	return {
+		isAnyFieldEdited,
+	};
 };

package/src/modules/card/composables/useCardComponent.ts

@@ -10,73 +10,75 @@ import { useCardValidation } from './useCardValidation';
 import { useItemCardSaveText } from './useItemCardSaveText';
 
 export const useCardComponent = <CardEntity>({
-  useCardStore,
+	useCardStore,
 }: {
-  useCardStore: StoreDefinition;
+	useCardStore: StoreDefinition;
 }) => {
-  const cardStore = useCardStore();
-
-  const {
-    itemId,
-    originalItemInstance,
-    validationSchema,
-    isLoading,
-    // isSaving, // todo: use me
-    // error, // todo: use me
-  } = storeToRefs(cardStore);
-
-  const { initialize, saveItem, $reset } = cardStore;
-
-  const { routeId } = useCardRouting({
-    itemId,
-  });
-
-  const { modelValue, validationFields, hasValidationErrors, validate } =
-    useCardValidation({ validationSchema });
-
-  const { isAnyFieldEdited } = useCardAnyFieldEditedWatcher({
-    value: modelValue,
-  });
-
-  const debouncedIsLoading = refDebounced(isLoading, 300);
-
-  const { isNew } = useCardIsNew({
-    itemId,
-  });
-
-  const { saveText } = useItemCardSaveText({
-    isNew,
-    isAnyFieldEdited,
-  });
-
-  const { save } = useCardSaveAction<CardEntity>({
-    // @ts-expect-error
-    validate, // fixme: type
-    saveItem,
-  });
-
-  initialize({
-    itemId: routeId.value,
-  });
-
-  onUnmounted($reset);
-
-  return {
-    // models
-    modelValue,
-
-    // state
-    debouncedIsLoading,
-    originalItemInstance,
-
-    // computed
-    isNew,
-    saveText,
-    hasValidationErrors,
-    isAnyFieldEdited,
-    validationFields,
-
-    // actions
-    save,
-  };
+	const cardStore = useCardStore();
+
+	const {
+		itemId,
+		originalItemInstance,
+		validationSchema,
+		isLoading,
+		// isSaving, // todo: use me
+		// error, // todo: use me
+	} = storeToRefs(cardStore);
+
+	const { initialize, saveItem, $reset } = cardStore;
+
+	const { routeId } = useCardRouting({
+		itemId,
+	});
+
+	const { modelValue, validationFields, hasValidationErrors, validate } =
+		useCardValidation({
+			validationSchema,
+		});
+
+	const { isAnyFieldEdited } = useCardAnyFieldEditedWatcher({
+		value: modelValue,
+	});
+
+	const debouncedIsLoading = refDebounced(isLoading, 300);
+
+	const { isNew } = useCardIsNew({
+		itemId,
+	});
+
+	const { saveText } = useItemCardSaveText({
+		isNew,
+		isAnyFieldEdited,
+	});
+
+	const { save } = useCardSaveAction<CardEntity>({
+		// @ts-expect-error
+		validate, // fixme: type
+		saveItem,
+	});
+
+	initialize({
+		itemId: routeId.value,
+	});
+
+	onUnmounted($reset);
+
+	return {
+		// models
+		modelValue,
+
+		// state
+		debouncedIsLoading,
+		originalItemInstance,
+
+		// computed
+		isNew,
+		saveText,
+		hasValidationErrors,
+		isAnyFieldEdited,
+		validationFields,
+
+		// actions
+		save,
+	};
 };

package/src/modules/card/composables/useCardIsNew.ts

@@ -1,11 +1,11 @@
-import {computed, Ref} from 'vue';
+import { computed, Ref } from 'vue';
 
 import { CardItemId } from '../types/CardStore.types';
 
 export const useCardIsNew = ({ itemId }: { itemId: Ref<CardItemId> }) => {
-  const isNew = computed(() => !itemId.value);
+	const isNew = computed(() => !itemId.value);
 
-  return {
-    isNew,
-  };
+	return {
+		isNew,
+	};
 };

package/src/modules/card/composables/useCardRouting.ts

@@ -1,31 +1,29 @@
-import {computed, Ref, watch} from 'vue';
+import { computed, Ref, watch } from 'vue';
 import { useRoute, useRouter } from 'vue-router';
 
-import {CardItemId} from "../types/CardStore.types";
+import { CardItemId } from '../types/CardStore.types';
 
-export const useCardRouting = ({ itemId }: {
-  itemId: Ref<CardItemId>;
-}) => {
-  const router = useRouter();
-  const route = useRoute();
+export const useCardRouting = ({ itemId }: { itemId: Ref<CardItemId> }) => {
+	const router = useRouter();
+	const route = useRoute();
 
-  const routeId = computed(() => {
-    return route.params.id;
-  });
+	const routeId = computed(() => {
+		return route.params.id;
+	});
 
-  const unwatch = watch(itemId, async (next, prev) => {
-    if (next && !prev) {
-      await router.replace({
-        params: {
-          ...route.params,
-          id: next,
-        },
-      });
-      unwatch(); // Stop watching after successful redirect "null" -> "id"
-    }
-  });
+	const unwatch = watch(itemId, async (next, prev) => {
+		if (next && !prev) {
+			await router.replace({
+				params: {
+					...route.params,
+					id: next,
+				},
+			});
+			unwatch(); // Stop watching after successful redirect "null" -> "id"
+		}
+	});
 
-  return {
-    routeId,
-  };
+	return {
+		routeId,
+	};
 };

package/src/modules/card/composables/useCardSaveAction.ts

@@ -1,20 +1,20 @@
-import {RegleSchemaResult} from "@regle/schemas";
+import { RegleSchemaResult } from '@regle/schemas';
 
 export const useCardSaveAction = <CardEntity>({
-    validate,
-    saveItem,
-                                  }: {
-    validate?: () => Promise<RegleSchemaResult<CardEntity>>;
-    saveItem: (data: CardEntity) => Promise<unknown /* coz doesnt matter */>;
+	validate,
+	saveItem,
+}: {
+	validate?: () => Promise<RegleSchemaResult<CardEntity>>;
+	saveItem: (data: CardEntity) => Promise<unknown /* coz doesnt matter */>;
 }) => {
-    const save = async () => {
-        const { valid, data } = await validate();
-        if (!valid) return;
+	const save = async () => {
+		const { valid, data } = await validate();
+		if (!valid) return;
 
-        return saveItem(data);
-    };
+		return saveItem(data);
+	};
 
-    return {
-        save,
-    };
-};
+	return {
+		save,
+	};
+};

package/src/modules/card/composables/useCardValidation.ts

@@ -1,34 +1,32 @@
-import {
-  RegleSchema,
-} from '@regle/schemas';
+import { RegleSchema } from '@regle/schemas';
 import { computed, Ref } from 'vue';
 
 export const useCardValidation = <TState, TSchema>({
-        validationSchema,
-                              }: {
-  validationSchema: Ref<RegleSchema<TState, TSchema>>,
+	validationSchema,
+}: {
+	validationSchema: Ref<RegleSchema<TState, TSchema>>;
 }) => {
-  const modelValue = computed(() => {
-    return validationSchema.value.r$.$value;
-  });
+	const modelValue = computed(() => {
+		return validationSchema.value.r$.$value;
+	});
 
-  const validationFields = computed(() => {
-    return validationSchema.value.r$.$fields;
-  });
+	const validationFields = computed(() => {
+		return validationSchema.value.r$.$fields;
+	});
 
-  const hasValidationErrors = computed(() => {
-    return validationSchema.value.r$.$error;
-  });
+	const hasValidationErrors = computed(() => {
+		return validationSchema.value.r$.$error;
+	});
 
-  const validate = () => {
-    return validationSchema.value.r$.$validate();
-  };
+	const validate = () => {
+		return validationSchema.value.r$.$validate();
+	};
 
-  return {
-    modelValue,
-    validationFields,
-    hasValidationErrors,
+	return {
+		modelValue,
+		validationFields,
+		hasValidationErrors,
 
-    validate,
-  };
+		validate,
+	};
 };

package/src/modules/card/composables/useItemCardSaveText.ts

@@ -2,21 +2,21 @@ import { computed, Ref } from 'vue';
 import { useI18n } from 'vue-i18n';
 
 export const useItemCardSaveText = ({
-  isNew,
-  isAnyFieldEdited,
-                                    }: {
-  isNew: Ref<boolean>;
-  isAnyFieldEdited: Ref<boolean>;
+	isNew,
+	isAnyFieldEdited,
+}: {
+	isNew: Ref<boolean>;
+	isAnyFieldEdited: Ref<boolean>;
 }) => {
-  const { t } = useI18n();
+	const { t } = useI18n();
 
-  const saveText = computed(() => {
-    return isNew.value || isAnyFieldEdited.value
-      ? t('reusable.save')
-      : t('reusable.saved');
-  });
+	const saveText = computed(() => {
+		return isNew.value || isAnyFieldEdited.value
+			? t('reusable.save')
+			: t('reusable.saved');
+	});
 
-  return {
-    saveText,
-  };
+	return {
+		saveText,
+	};
 };