rename types

Author: v-rudkovskiy

package-lock.json

@@ -61,8 +61,10 @@
     "typecheck": "tsc --noEmit",
     "lint:typecheck": "npm run lint && npm run typecheck"
   },
+  "peerDependencies": {
+    "axios": "^1.9.0"
+  },
   "dependencies": {
-    "axios": "^1.8.4",
     "btoa": "^1.2.1"
   },
   "devDependencies": {
@@ -71,6 +73,7 @@
     "@typescript-eslint/eslint-plugin": "^8.29.1",
     "@typescript-eslint/parser": "^8.29.1",
     "@vitest/eslint-plugin": "^1.1.43",
+    "axios": "^1.9.0",
     "eslint": "^9.24.0",
     "eslint-plugin-import": "^2.31.0",
     "prettier": "3.5.3",

package.json

@@ -11,12 +11,12 @@ import ProductDiscount from '@/entities/ProductDiscount';
 // types
 import { Item } from '@/types/api/response';
 import { ProductProps } from '@/types/entities/Product';
-import { ProductDiscount as IProductDiscount } from '@/types/entities/ProductDiscount';
+import { ProductDiscountEntity } from '@/types/entities/ProductDiscount';
 
 export default <T extends object = ProductProps>(item?: Item) => {
   const props = itemToObject<Record<string, unknown>>(item);
 
-  const discounts: IProductDiscount[] | undefined = props.discount as IProductDiscount[] | undefined;
+  const discounts: ProductDiscountEntity[] | undefined = props.discount as ProductDiscountEntity[] | undefined;
   delete props.discount;
 
   if (discounts) {

src/converters/itemToProduct.ts

@@ -6,7 +6,7 @@
  */
 
 // types
-import type { BundleProps, BundleMethods, Bundle as IBundle } from '@/types/entities/Bundle';
+import type { BundleProps, BundleMethods, BundleEntity } from '@/types/entities/Bundle';
 
 // utils
 import { set, get } from '@/utils/helpers';
@@ -43,74 +43,74 @@ import defineEntity from './defineEntity';
  * Arbitrary additional user properties of string type may be associated with each bundle. The name of user property
  * must not be equal to any of the fixed property names listed above and must be none of id, deleted.
  */
-const Bundle = function <T extends object>(properties: BundleProps<T> = {} as BundleProps<T>): IBundle<T> {
+const Bundle = function <T extends object>(properties: BundleProps<T> = {} as BundleProps<T>): BundleEntity<T> {
   const props: BundleProps = { ...properties };
 
   const methods: BundleMethods = {
-    setActive(active: boolean) {
+    setActive(this: void, active: boolean) {
       set(props, 'active', active);
     },
 
-    getActive<D = undefined>(def?: D): boolean | D {
+    getActive<D = undefined>(this: void, def?: D): boolean | D {
       return get(props, 'active', def) as boolean | D;
     },
 
-    setNumber(number: string) {
+    setNumber(this: void, number: string) {
       set(props, 'number', number);
     },
 
-    getNumber<D = undefined>(def?: D): string | D {
+    getNumber<D = undefined>(this: void, def?: D): string | D {
       return get(props, 'number', def) as string | D;
     },
 
-    setName(name: string): void {
+    setName(this: void, name: string): void {
       set(props, 'name', name);
     },
 
-    getName<D = undefined>(def?: D): string | D {
+    getName<D = undefined>(this: void, def?: D): string | D {
       return get(props, 'name', def) as string | D;
     },
 
-    setPrice(price: number): void {
+    setPrice(this: void, price: number): void {
       set(props, 'price', price);
     },
 
-    getPrice<D = undefined>(def?: D): number | D {
+    getPrice<D = undefined>(this: void, def?: D): number | D {
       return get(props, 'price', def) as number | D;
     },
 
-    setCurrency(currency: string): void {
+    setCurrency(this: void, currency: string): void {
       set(props, 'currency', currency);
     },
 
-    getCurrency<D = undefined>(def?: D): string | D {
+    getCurrency<D = undefined>(this: void, def?: D): string | D {
       return get(props, 'currency', def) as string | D;
     },
 
-    setLicenseTemplateNumbers(numbers: string[]): void {
+    setLicenseTemplateNumbers(this: void, numbers: string[]): void {
       set(props, 'licenseTemplateNumbers', numbers);
     },
 
-    addLicenseTemplateNumber(number: string): void {
+    addLicenseTemplateNumber(this: void, number: string): void {
       if (!props.licenseTemplateNumbers) {
         props.licenseTemplateNumbers = [];
       }
 
       props.licenseTemplateNumbers.push(number);
     },
 
-    getLicenseTemplateNumbers<D = undefined>(def?: D): string[] | D {
+    getLicenseTemplateNumbers<D = undefined>(this: void, def?: D): string[] | D {
       return get(props, 'licenseTemplateNumbers', def) as string[] | D;
     },
 
-    removeLicenseTemplateNumber(number: string): void {
+    removeLicenseTemplateNumber(this: void, number: string): void {
       const { licenseTemplateNumbers: numbers = [] } = props;
 
       numbers.splice(numbers.indexOf(number), 1);
       props.licenseTemplateNumbers = numbers;
     },
 
-    serialize(): Record<string, string> {
+    serialize(this: void): Record<string, string> {
       if (props.licenseTemplateNumbers) {
         const licenseTemplateNumbers = props.licenseTemplateNumbers.join(',');
         return serialize({ ...props, licenseTemplateNumbers });

src/entities/Bundle.ts

@@ -5,7 +5,7 @@
  * @copyright 2017 Labs64 NetLicensing
  */
 // types
-import type { CountryProps, CountryMethods, Country as ICountry } from '@/types/entities/Country';
+import type { CountryProps, CountryMethods, CountryEntity } from '@/types/entities/Country';
 
 // entity factory
 import defineEntity from './defineEntity';
@@ -20,7 +20,7 @@ import defineEntity from './defineEntity';
  * @property vatPercent - Country vat.
  * @property isEu - is country in EU.
  */
-const Country = function (properties: CountryProps = {} as CountryProps): ICountry {
+const Country = function (properties: CountryProps = {} as CountryProps): CountryEntity {
   const defaults: CountryProps = {
     code: '',
     name: '',
@@ -31,19 +31,19 @@ const Country = function (properties: CountryProps = {} as CountryProps): ICount
   const props: CountryProps = { ...defaults, ...properties };
 
   const methods: CountryMethods = {
-    getCode(): string {
+    getCode(this: void): string {
       return props.code;
     },
 
-    getName(): string {
+    getName(this: void): string {
       return props.name;
     },
 
-    getVatPercent(): number {
+    getVatPercent(this: void): number {
       return props.vatPercent as number;
     },
 
-    getIsEu(): boolean {
+    getIsEu(this: void): boolean {
       return props.isEu;
     },
   };