@vulog/aima-mobility-plans 1.1.59

package/.eslintrc.js

@@ -0,0 +1,112 @@
+module.exports = {
+    parser: '@typescript-eslint/parser',
+    parserOptions: {
+        // Indicates the location of the TypeScript configuration file
+        project: 'tsconfig.json',
+        // Sets the root directory for the TypeScript configuration
+        tsconfigRootDir: __dirname,
+        // Specifies the version of ECMAScript syntax to be used
+        ecmaVersion: 'latest',
+        // Indicates the type of source code (script or module)
+        sourceType: 'module',
+    },
+    plugins: ['@typescript-eslint', 'prettier', 'import'],
+    extends: [
+        'airbnb-base',
+        'airbnb-typescript/base',
+        'plugin:@typescript-eslint/recommended',
+        'prettier',
+        'plugin:prettier/recommended',
+    ],
+    root: true,
+    env: {
+        es6: true,
+        node: true,
+    },
+    ignorePatterns: [
+        '/dist/**/*', // Ignore built files.
+        '.eslintrc.js',
+        '**/*.test.ts',
+    ],
+    rules: {
+        // Configures the Prettier integration with ESLint
+        'prettier/prettier': ['error', { endOfLine: 'auto' }],
+        // Disables the rule requiring an 'I' prefix for interfaces
+        '@typescript-eslint/interface-name-prefix': 'off',
+        // Configures the naming conventions for various code constructs
+        '@typescript-eslint/naming-convention': [
+            // ... various naming convention configurations ...
+            'error',
+            // Allows any naming format for destructured variables
+            {
+                selector: 'variable',
+                modifiers: ['destructured'],
+                format: null,
+            },
+            // Requires strict camelCase for function names
+            {
+                selector: 'function',
+                format: ['strictCamelCase'],
+            },
+            // Requires boolean variables to have one of the specified prefixes
+            {
+                selector: 'variable',
+                format: null,
+                types: ['boolean'],
+                prefix: ['is', 'should', 'has', 'can', 'did', 'will'],
+            },
+            // Requires enum names to have a strict PascalCase format
+            {
+                selector: 'enum',
+                format: ['StrictPascalCase'],
+            },
+        ],
+        'import/extensions': 'off',
+        // Disables the rule requiring explicit return types for functions
+        '@typescript-eslint/explicit-function-return-type': 'off',
+        // Disables the rule requiring explicit boundary types for modules
+        '@typescript-eslint/explicit-module-boundary-types': 'off',
+        // Disables the rule prohibiting the use of 'any' type
+        '@typescript-eslint/no-explicit-any': 'off',
+        // Disables the rule detecting unused variables
+        'no-unused-vars': 0,
+        // Disables the rule disallowing named exports used as a default export
+        'import/no-named-as-default': 0,
+        // Configures the order and formatting of import statements
+        'import/order': [
+            // ... import order configuration ...
+            'error',
+            {
+                // Configure the alphabetization settings
+                alphabetize: {
+                    // Enforce ascending alphabetical order
+                    order: 'asc',
+                    // Do not ignore the case while sorting
+                    caseInsensitive: false,
+                },
+                // Enforce newlines between different groups and inside groups of imports
+                'newlines-between': 'always-and-inside-groups',
+                // Warn when there is an import statement that is not part of any group
+                warnOnUnassignedImports: true,
+            },
+        ],
+        // Configures the rule detecting extraneous dependencies
+        'import/no-extraneous-dependencies': [
+            // ... extraneous dependencies configuration ...
+            'error',
+            {
+                // Specify the file patterns where devDependencies imports are allowed
+                devDependencies: [
+                    // Allow devDependencies imports in test and spec files
+                    '**/*.test.{ts,js}',
+                    '**/*.spec.{ts,js}',
+                    // Allow devDependencies imports in the 'test' folder
+                    './test/**.{ts,js}',
+                    // Allow devDependencies imports in the 'scripts' folder
+                    './scripts/**/*.{ts,js}',
+                ],
+            },
+        ],
+        'import/prefer-default-export': 'off',
+    },
+};

package/README.md

@@ -0,0 +1 @@
+# @vulog/aima-product

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+import { Client } from '@vulog/aima-client';
+
+type Status = 'ACTIVE' | 'INACTIVE';
+type Plan = {
+    id: string;
+    name: string;
+    fleetId: string;
+    period: 'WEEK' | 'MONTH' | 'YEAR';
+    productId: string;
+    systemCreditIncluded: number;
+    price: number;
+    cities: {
+        cityId: string;
+        serviceIds: string[];
+    }[];
+    status: Status;
+    periodicTimeWallet: {
+        freeMinutes: number;
+        freeMinutesFrequency: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+    };
+    services: string[];
+};
+type Subscription = [
+    {
+        id: string;
+        profileId: string;
+        plan: Plan;
+        fleetId: string;
+        expiryDate: Date | null;
+        unsubscribeDate: Date | null;
+        activationDate: Date | null;
+        invoiceIds: string[];
+        status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+    }
+];
+
+declare const getPlans: (client: Client, status: Status) => Promise<Plan[]>;
+
+declare const getUserPlans: (client: Client, entityId: string) => Promise<Subscription[]>;
+
+type UnsubscribeResponse = {
+    id: string;
+    profileId: string;
+    plan: Plan;
+    fleetId: string;
+    expiryDate: string;
+    unsubscribeDate: string;
+    activationDate: string;
+    invoiceIds: string[];
+    status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+};
+declare const unsubscribe: (client: Client, entityId: string, profileId: string) => Promise<UnsubscribeResponse>;
+
+export { type Plan, type Status, type Subscription, getPlans, getUserPlans, unsubscribe };

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import { Client } from '@vulog/aima-client';
+
+type Status = 'ACTIVE' | 'INACTIVE';
+type Plan = {
+    id: string;
+    name: string;
+    fleetId: string;
+    period: 'WEEK' | 'MONTH' | 'YEAR';
+    productId: string;
+    systemCreditIncluded: number;
+    price: number;
+    cities: {
+        cityId: string;
+        serviceIds: string[];
+    }[];
+    status: Status;
+    periodicTimeWallet: {
+        freeMinutes: number;
+        freeMinutesFrequency: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+    };
+    services: string[];
+};
+type Subscription = [
+    {
+        id: string;
+        profileId: string;
+        plan: Plan;
+        fleetId: string;
+        expiryDate: Date | null;
+        unsubscribeDate: Date | null;
+        activationDate: Date | null;
+        invoiceIds: string[];
+        status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+    }
+];
+
+declare const getPlans: (client: Client, status: Status) => Promise<Plan[]>;
+
+declare const getUserPlans: (client: Client, entityId: string) => Promise<Subscription[]>;
+
+type UnsubscribeResponse = {
+    id: string;
+    profileId: string;
+    plan: Plan;
+    fleetId: string;
+    expiryDate: string;
+    unsubscribeDate: string;
+    activationDate: string;
+    invoiceIds: string[];
+    status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+};
+declare const unsubscribe: (client: Client, entityId: string, profileId: string) => Promise<UnsubscribeResponse>;
+
+export { type Plan, type Status, type Subscription, getPlans, getUserPlans, unsubscribe };

package/dist/index.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  getPlans: () => getPlans,
+  getUserPlans: () => getUserPlans,
+  unsubscribe: () => unsubscribe
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/getPlans.ts
+var import_zod = require("zod");
+var schema = import_zod.z.object({
+  status: import_zod.z.enum(["ACTIVE", "INACTIVE"])
+});
+var getPlans = async (client, status) => {
+  const result = schema.safeParse({ status });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/plans?size=1000&status=${status}`).then(({ data }) => data);
+};
+
+// src/getUserPlans.ts
+var import_zod2 = require("zod");
+var schema2 = import_zod2.z.object({
+  entityId: import_zod2.z.string().uuid()
+});
+var getUserPlans = async (client, entityId) => {
+  const result = schema2.safeParse({ entityId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions?entityId=${entityId}&status=ACTIVE,PAYMENT_PENDING,ACTIVATION_PENDING`).then(({ data }) => data);
+};
+
+// src/unsubscribe.ts
+var import_zod3 = require("zod");
+var schema3 = import_zod3.z.object({
+  entityId: import_zod3.z.string().uuid(),
+  profileId: import_zod3.z.string().uuid()
+});
+var unsubscribe = async (client, entityId, profileId) => {
+  const result = schema3.safeParse({ entityId, profileId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions/${entityId}/unsubscribe`,
+    {
+      profileId
+    }
+  ).then(({ data }) => data);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPlans,
+  getUserPlans,
+  unsubscribe
+});

package/dist/index.mjs

@@ -0,0 +1,55 @@
+// src/getPlans.ts
+import { z } from "zod";
+var schema = z.object({
+  status: z.enum(["ACTIVE", "INACTIVE"])
+});
+var getPlans = async (client, status) => {
+  const result = schema.safeParse({ status });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/plans?size=1000&status=${status}`).then(({ data }) => data);
+};
+
+// src/getUserPlans.ts
+import { z as z2 } from "zod";
+var schema2 = z2.object({
+  entityId: z2.string().uuid()
+});
+var getUserPlans = async (client, entityId) => {
+  const result = schema2.safeParse({ entityId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.get(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions?entityId=${entityId}&status=ACTIVE,PAYMENT_PENDING,ACTIVATION_PENDING`).then(({ data }) => data);
+};
+
+// src/unsubscribe.ts
+import { z as z3 } from "zod";
+var schema3 = z3.object({
+  entityId: z3.string().uuid(),
+  profileId: z3.string().uuid()
+});
+var unsubscribe = async (client, entityId, profileId) => {
+  const result = schema3.safeParse({ entityId, profileId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  return client.post(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions/${entityId}/unsubscribe`,
+    {
+      profileId
+    }
+  ).then(({ data }) => data);
+};
+export {
+  getPlans,
+  getUserPlans,
+  unsubscribe
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@vulog/aima-mobility-plans",
+    "version": "1.1.59",
+    "main": "dist/index.js",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsup",
+        "dev": "tsup --watch",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "lint": "eslint src/**/* --ext .ts"
+    },
+    "keywords": [
+        "AIMA",
+        "VULOG",
+        "MOBILITY",
+        "PLANS"
+    ],
+    "author": "Vulog",
+    "license": "ISC",
+    "dependencies": {
+        "@vulog/aima-client": "1.1.59",
+        "@vulog/aima-core": "1.1.59"
+    },
+    "peerDependencies": {
+        "zod": "^3.24.2"
+    },
+    "description": ""
+}

package/src/getPlans.test.ts

@@ -0,0 +1,79 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getPlans } from './getPlans';
+
+describe('getPlans', () => {
+    const FLEET_ID = 'FLEET_ID';
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: FLEET_ID,
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    test('call OK', async () => {
+        const data = [
+            {
+                id: 'plan1',
+                name: 'Plan 1',
+                fleetId: FLEET_ID,
+                period: 'MONTH',
+                productId: 'product1',
+                systemCreditIncluded: 100,
+                cities: [
+                    {
+                        cityId: 'city1',
+                        serviceIds: ['service1', 'service2'],
+                    },
+                ],
+                periodicTimeWallet: {
+                    freeMinutes: 30,
+                    freeMinutesFrequency: 'DAILY',
+                },
+                services: ['service1', 'service2'],
+                status: 'ACTIVE',
+                price: 10,
+            },
+            {
+                id: 'plan2',
+                name: 'Plan 2',
+                fleetId: FLEET_ID,
+                period: 'YEAR',
+                productId: 'product2',
+                systemCreditIncluded: 200,
+                cities: [
+                    {
+                        cityId: 'city2',
+                        serviceIds: ['service3'],
+                    },
+                ],
+                periodicTimeWallet: {
+                    freeMinutes: 60,
+                    freeMinutesFrequency: 'WEEKLY',
+                },
+                services: ['service3'],
+                status: 'ACTIVE',
+                price: 100,
+            },
+        ];
+        getMock.mockResolvedValueOnce({ data });
+
+        const result = await getPlans(client, 'ACTIVE');
+        expect(result).toEqual(data);
+        expect(getMock).toHaveBeenCalledWith(`/boapi/proxy/user/fleets/${FLEET_ID}/plans?size=1000&status=ACTIVE`);
+    });
+
+    test('call with invalid status', async () => {
+        await expect(getPlans(client, 'INVALID' as any)).rejects.toThrow(TypeError);
+    });
+});

package/src/getPlans.ts

@@ -0,0 +1,20 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Plan, Status } from './types';
+
+const schema = z.object({
+    status: z.enum(['ACTIVE', 'INACTIVE']),
+});
+
+export const getPlans = async (client: Client, status: Status): Promise<Plan[]> => {
+    const result = schema.safeParse({ status });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<Plan[]>(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/plans?size=1000&status=${status}`)
+        .then(({ data }) => data);
+};

package/src/getUserPlans.test.ts

@@ -0,0 +1,64 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { getUserPlans } from './getUserPlans';
+
+describe('getUserPlans', () => {
+    const FLEET_ID = 'FLEET_ID';
+    const ENTITY_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+    const getMock = vi.fn();
+    const client = {
+        get: getMock,
+        clientOptions: {
+            fleetId: FLEET_ID,
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        getMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    test('call OK', async () => {
+        const data = [
+            {
+                id: 'plan1',
+                name: 'Plan 1',
+                fleetId: FLEET_ID,
+                period: 'MONTH',
+                productId: 'product1',
+                systemCreditIncluded: 100,
+                cities: [
+                    {
+                        cityId: 'city1',
+                        serviceIds: ['service1', 'service2'],
+                    },
+                ],
+                periodicTimeWallet: {
+                    freeMinutes: 30,
+                    freeMinutesFrequency: 'DAILY',
+                },
+                services: ['service1', 'service2'],
+                status: 'ACTIVE',
+                price: 10,
+            },
+        ];
+
+        getMock.mockResolvedValue({ data });
+
+        const result = await getUserPlans(client, ENTITY_ID);
+        expect(result).toEqual(data);
+        expect(getMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/fleets/${FLEET_ID}/subscriptions?entityId=${ENTITY_ID}&status=ACTIVE,PAYMENT_PENDING,ACTIVATION_PENDING`
+        );
+        expect(getMock).toHaveBeenCalledTimes(1);
+    });
+
+    test('invalid entityId', async () => {
+        await expect(getUserPlans(client, 'invalid-entity-id' as any)).rejects.toThrow(TypeError);
+        expect(getMock).not.toHaveBeenCalled();
+    });
+});

package/src/getUserPlans.ts

@@ -0,0 +1,22 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Subscription } from './types';
+
+const schema = z.object({
+    entityId: z.string().uuid(),
+});
+
+export const getUserPlans = async (client: Client, entityId: string): Promise<Subscription[]> => {
+    const result = schema.safeParse({ entityId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    return client
+        .get<
+            Subscription[]
+        >(`/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions?entityId=${entityId}&status=ACTIVE,PAYMENT_PENDING,ACTIVATION_PENDING`)
+        .then(({ data }) => data);
+};

package/src/index.ts

@@ -0,0 +1,4 @@
+export { getPlans } from './getPlans';
+export { getUserPlans } from './getUserPlans';
+export { unsubscribe } from './unsubscribe';
+export type { Plan, Status, Subscription } from './types';

package/src/types.ts

@@ -0,0 +1,35 @@
+export type Status = 'ACTIVE' | 'INACTIVE';
+
+export type Plan = {
+    id: string;
+    name: string;
+    fleetId: string;
+    period: 'WEEK' | 'MONTH' | 'YEAR';
+    productId: string;
+    systemCreditIncluded: number;
+    price: number;
+    cities: {
+        cityId: string;
+        serviceIds: string[];
+    }[];
+    status: Status;
+    periodicTimeWallet: {
+        freeMinutes: number;
+        freeMinutesFrequency: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+    };
+    services: string[];
+};
+
+export type Subscription = [
+    {
+        id: string;
+        profileId: string;
+        plan: Plan;
+        fleetId: string;
+        expiryDate: Date | null;
+        unsubscribeDate: Date | null;
+        activationDate: Date | null;
+        invoiceIds: string[];
+        status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+    },
+];

package/src/unsubscribe.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Client } from '@vulog/aima-client';
+import { unsubscribe } from './unsubscribe';
+
+describe('unsubscribe', () => {
+    const FLEET_ID = 'FLEET_ID';
+    const ENTITY_ID = '018ab2b6-71b2-4c76-90bd-6e8d3f268618';
+    const PROFILE_ID = '61bdc58e-a6d0-4f6a-b9bd-727b17ead122';
+    const postMock = vi.fn();
+    const client = {
+        post: postMock,
+        clientOptions: {
+            fleetId: FLEET_ID,
+        },
+    } as unknown as Client;
+
+    beforeEach(() => {
+        postMock.mockReset();
+        vi.useFakeTimers({ now: new Date('2025-01-12T13:35:50.123Z') });
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+
+    test('call OK', async () => {
+        const data = { success: true };
+        postMock.mockResolvedValue({ data });
+
+        const result = await unsubscribe(client, ENTITY_ID, PROFILE_ID);
+        expect(result).toEqual(data);
+        expect(postMock).toHaveBeenCalledWith(
+            `/boapi/proxy/user/fleets/${FLEET_ID}/subscriptions/${ENTITY_ID}/unsubscribe`,
+            { profileId: PROFILE_ID }
+        );
+        expect(postMock).toHaveBeenCalledTimes(1);
+    });
+
+    test('invalid entityId', async () => {
+        await expect(unsubscribe(client, '', '')).rejects.toThrow('Invalid args');
+        expect(postMock).not.toHaveBeenCalled();
+    });
+});

package/src/unsubscribe.ts

@@ -0,0 +1,43 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+import { Plan } from './types';
+
+const schema = z.object({
+    entityId: z.string().uuid(),
+    profileId: z.string().uuid(),
+});
+
+type UnsubscribeResponse = {
+    id: string;
+    profileId: string;
+    plan: Plan;
+    fleetId: string;
+    expiryDate: string;
+    unsubscribeDate: string;
+    activationDate: string;
+    invoiceIds: string[];
+    status: 'ACTIVE' | 'PAYMENT_PENDING' | 'ACTIVATION_PENDING';
+};
+
+export const unsubscribe = async (
+    client: Client,
+    entityId: string,
+    profileId: string
+): Promise<UnsubscribeResponse> => {
+    const result = schema.safeParse({ entityId, profileId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    // https://java-sta.vulog.com/boapi/proxy/user/fleets/LEO-CAMTR/subscriptions/c360b6d9-659f-4547-8840-58e39a753b0a/unsubscribe
+    return client
+        .post<UnsubscribeResponse>(
+            `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/subscriptions/${entityId}/unsubscribe`,
+            {
+                profileId,
+            }
+        )
+        .then(({ data }) => data);
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "include": ["src"],
+    "exclude": ["**/*.test.ts"],
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "esnext",
+        "lib": ["esnext"],
+        "declaration": true,
+        "strict": true,
+        "moduleResolution": "node",
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "outDir": "dist",
+        "rootDir": "src"
+    }
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    clean: true,
+    format: ['cjs', 'esm'],
+    dts: true,
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+    },
+});