@vitnode/core 1.2.0-canary.51 → 1.2.0-canary.53

package/dist/src/lib/helpers/auto-form.test.js

@@ -1,70 +1,70 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
 import { getDefaults, getNestedParam, getZodInputParams } from "./auto-form.js";
-describe('auto-form helpers', ()=>{
-    describe('getDefaults', ()=>{
-        it('should return empty object when no schema provided', ()=>{
+describe("auto-form helpers", ()=>{
+    describe("getDefaults", ()=>{
+        it("should return empty object when no schema provided", ()=>{
             expect(getDefaults()).toEqual({});
         });
-        it('should return empty object when schema has no properties', ()=>{
+        it("should return empty object when schema has no properties", ()=>{
             const schema = {};
             expect(getDefaults(schema)).toEqual({});
         });
-        it('should extract default values from simple Zod schema', ()=>{
+        it("should extract default values from simple Zod schema", ()=>{
             const zodSchema = z.object({
-                name: z.string().default('John Doe'),
+                name: z.string().default("John Doe"),
                 age: z.number().default(25),
                 active: z.boolean().default(true)
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getDefaults(jsonSchema);
             expect(result).toEqual({
-                name: 'John Doe',
+                name: "John Doe",
                 age: 25,
                 active: true
             });
         });
-        it('should handle nested Zod objects with defaults', ()=>{
+        it("should handle nested Zod objects with defaults", ()=>{
             const zodSchema = z.object({
                 user: z.object({
-                    name: z.string().default('Jane'),
+                    name: z.string().default("Jane"),
                     settings: z.object({
-                        theme: z.string().default('dark'),
+                        theme: z.string().default("dark"),
                         notifications: z.boolean().default(false)
                     })
                 }),
-                title: z.string().default('Hello')
+                title: z.string().default("Hello")
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getDefaults(jsonSchema);
             expect(result).toEqual({
                 user: {
-                    name: 'Jane',
+                    name: "Jane",
                     settings: {
-                        theme: 'dark',
+                        theme: "dark",
                         notifications: false
                     }
                 },
-                title: 'Hello'
+                title: "Hello"
             });
         });
-        it('should skip nested objects with no default values', ()=>{
+        it("should skip nested objects with no default values", ()=>{
             const zodSchema = z.object({
                 user: z.object({
                     name: z.string(),
                     email: z.string()
                 }),
-                title: z.string().default('Hello')
+                title: z.string().default("Hello")
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getDefaults(jsonSchema);
             expect(result).toEqual({
-                title: 'Hello'
+                title: "Hello"
             });
         });
-        it('should handle mixed properties with and without defaults', ()=>{
+        it("should handle mixed properties with and without defaults", ()=>{
             const zodSchema = z.object({
-                name: z.string().default('Test'),
+                name: z.string().default("Test"),
                 email: z.string(),
                 age: z.number().default(30),
                 bio: z.string()
@@ -72,52 +72,52 @@ describe('auto-form helpers', ()=>{
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getDefaults(jsonSchema);
             expect(result).toEqual({
-                name: 'Test',
+                name: "Test",
                 age: 30
             });
         });
     });
-    describe('getZodInputParams', ()=>{
-        it('should return empty object when no schema provided', ()=>{
+    describe("getZodInputParams", ()=>{
+        it("should return empty object when no schema provided", ()=>{
             expect(getZodInputParams()).toEqual({});
         });
-        it('should return empty object when schema has no properties', ()=>{
+        it("should return empty object when schema has no properties", ()=>{
             const schema = {};
             expect(getZodInputParams(schema)).toEqual({});
         });
-        it('should extract basic string field parameters from Zod schema', ()=>{
+        it("should extract basic string field parameters from Zod schema", ()=>{
             const zodSchema = z.object({
-                name: z.string().min(2).max(50).regex(/^[a-zA-Z]+$/).describe('User name')
+                name: z.string().min(2).max(50).regex(/^[a-zA-Z]+$/).describe("User name")
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema, [
-                'name'
+                "name"
             ]);
             expect(result).toEqual({
                 name: {
-                    type: 'text',
+                    type: "text",
                     minLength: 2,
                     maxLength: 50,
-                    pattern: '^[a-zA-Z]+$',
-                    description: 'User name',
+                    pattern: "^[a-zA-Z]+$",
+                    description: "User name",
                     required: true
                 }
             });
         });
-        it('should handle email format from Zod schema', ()=>{
+        it("should handle email format from Zod schema", ()=>{
             const zodSchema = z.object({
-                email: z.email().describe('Email address')
+                email: z.email().describe("Email address")
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema, [
-                'email'
+                "email"
             ]);
-            expect(result.email).toHaveProperty('type', 'email');
-            expect(result.email).toHaveProperty('description', 'Email address');
-            expect(result.email).toHaveProperty('required', true);
-            expect(result.email).toHaveProperty('pattern'); // Email pattern is generated
+            expect(result.email).toHaveProperty("type", "email");
+            expect(result.email).toHaveProperty("description", "Email address");
+            expect(result.email).toHaveProperty("required", true);
+            expect(result.email).toHaveProperty("pattern"); // Email pattern is generated
         });
-        it('should infer password type from field name', ()=>{
+        it("should infer password type from field name", ()=>{
             const zodSchema = z.object({
                 password: z.string(),
                 confirmPassword: z.string(),
@@ -125,14 +125,14 @@ describe('auto-form helpers', ()=>{
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result.password).toHaveProperty('type', 'password');
-            expect(result.password).toHaveProperty('required', true);
-            expect(result.confirmPassword).toHaveProperty('type', 'password');
-            expect(result.confirmPassword).toHaveProperty('required', true);
-            expect(result.userPassword).toHaveProperty('type', 'password');
-            expect(result.userPassword).toHaveProperty('required', true);
+            expect(result.password).toHaveProperty("type", "password");
+            expect(result.password).toHaveProperty("required", true);
+            expect(result.confirmPassword).toHaveProperty("type", "password");
+            expect(result.confirmPassword).toHaveProperty("required", true);
+            expect(result.userPassword).toHaveProperty("type", "password");
+            expect(result.userPassword).toHaveProperty("required", true);
         });
-        it('should handle number and boolean types from Zod schema', ()=>{
+        it("should handle number and boolean types from Zod schema", ()=>{
             const zodSchema = z.object({
                 age: z.number(),
                 count: z.number().int(),
@@ -140,41 +140,41 @@ describe('auto-form helpers', ()=>{
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result.age).toHaveProperty('type', 'number');
-            expect(result.age).toHaveProperty('required', true);
-            expect(result.count).toHaveProperty('type', 'number');
-            expect(result.count).toHaveProperty('required', true);
-            expect(result.active).toHaveProperty('type', 'checkbox');
-            expect(result.active).toHaveProperty('required', true);
+            expect(result.age).toHaveProperty("type", "number");
+            expect(result.age).toHaveProperty("required", true);
+            expect(result.count).toHaveProperty("type", "number");
+            expect(result.count).toHaveProperty("required", true);
+            expect(result.active).toHaveProperty("type", "checkbox");
+            expect(result.active).toHaveProperty("required", true);
         });
-        it('should handle enum values from Zod schema', ()=>{
+        it("should handle enum values from Zod schema", ()=>{
             const zodSchema = z.object({
                 role: z.enum([
-                    'admin',
-                    'user',
-                    'guest'
+                    "admin",
+                    "user",
+                    "guest"
                 ])
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result.role).toHaveProperty('type', 'text');
-            expect(result.role).toHaveProperty('enum', [
-                'admin',
-                'user',
-                'guest'
+            expect(result.role).toHaveProperty("type", "text");
+            expect(result.role).toHaveProperty("enum", [
+                "admin",
+                "user",
+                "guest"
             ]);
-            expect(result.role).toHaveProperty('required', true);
+            expect(result.role).toHaveProperty("required", true);
         });
-        it('should handle complex password validation', ()=>{
+        it("should handle complex password validation", ()=>{
             const zodSchema = z.object({
-                password: z.string().min(8).regex(/(?=.*[a-z])/, 'Must contain lowercase').regex(/(?=.*[A-Z])/, 'Must contain uppercase').regex(/(?=.*\d)/, 'Must contain number')
+                password: z.string().min(8).regex(/(?=.*[a-z])/, "Must contain lowercase").regex(/(?=.*[A-Z])/, "Must contain uppercase").regex(/(?=.*\d)/, "Must contain number")
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result.password).toHaveProperty('type', 'password');
-            expect(result.password).toHaveProperty('minLength', 8);
+            expect(result.password).toHaveProperty("type", "password");
+            expect(result.password).toHaveProperty("minLength", 8);
         });
-        it('should handle nested objects from Zod schema', ()=>{
+        it("should handle nested objects from Zod schema", ()=>{
             const zodSchema = z.object({
                 user: z.object({
                     name: z.string(),
@@ -182,22 +182,22 @@ describe('auto-form helpers', ()=>{
                 }),
                 settings: z.object({
                     theme: z.enum([
-                        'light',
-                        'dark'
+                        "light",
+                        "dark"
                     ]),
                     notifications: z.boolean()
                 })
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema, [
-                'user'
+                "user"
             ]);
-            expect(result.user).toHaveProperty('name');
-            expect(result.user).toHaveProperty('email');
-            expect(result.settings).toHaveProperty('theme');
-            expect(result.settings).toHaveProperty('notifications');
+            expect(result.user).toHaveProperty("name");
+            expect(result.user).toHaveProperty("email");
+            expect(result.settings).toHaveProperty("theme");
+            expect(result.settings).toHaveProperty("notifications");
         });
-        it('should handle required fields from Zod schema', ()=>{
+        it("should handle required fields from Zod schema", ()=>{
             const zodSchema = z.object({
                 name: z.string(),
                 email: z.string(),
@@ -205,14 +205,14 @@ describe('auto-form helpers', ()=>{
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema, [
-                'name',
-                'email'
+                "name",
+                "email"
             ]);
-            expect(result.name).toHaveProperty('required', true);
-            expect(result.email).toHaveProperty('required', true);
-            expect(result.age).not.toHaveProperty('required');
+            expect(result.name).toHaveProperty("required", true);
+            expect(result.email).toHaveProperty("required", true);
+            expect(result.age).not.toHaveProperty("required");
         });
-        it('should handle optional fields from Zod schema', ()=>{
+        it("should handle optional fields from Zod schema", ()=>{
             const zodSchema = z.object({
                 name: z.string(),
                 email: z.string().optional(),
@@ -220,116 +220,116 @@ describe('auto-form helpers', ()=>{
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema, [
-                'name'
+                "name"
             ]);
-            expect(result.name).toHaveProperty('required', true);
-            expect(result.email).not.toHaveProperty('required');
-            expect(result.age).not.toHaveProperty('required');
+            expect(result.name).toHaveProperty("required", true);
+            expect(result.email).not.toHaveProperty("required");
+            expect(result.age).not.toHaveProperty("required");
         });
-        it('should handle union types from Zod schema', ()=>{
+        it("should handle union types from Zod schema", ()=>{
             const zodSchema = z.object({
                 status: z.union([
-                    z.literal('active'),
-                    z.literal('inactive')
+                    z.literal("active"),
+                    z.literal("inactive")
                 ]),
                 priority: z.number().or(z.string())
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result).toHaveProperty('status');
-            expect(result).toHaveProperty('priority');
+            expect(result).toHaveProperty("status");
+            expect(result).toHaveProperty("priority");
         });
-        it('should handle array types from Zod schema', ()=>{
+        it("should handle array types from Zod schema", ()=>{
             const zodSchema = z.object({
                 tags: z.array(z.string()),
                 numbers: z.array(z.number())
             });
             const jsonSchema = z.toJSONSchema(zodSchema);
             const result = getZodInputParams(jsonSchema);
-            expect(result).toHaveProperty('tags');
-            expect(result).toHaveProperty('numbers');
+            expect(result).toHaveProperty("tags");
+            expect(result).toHaveProperty("numbers");
         });
     });
-    describe('getNestedParam', ()=>{
+    describe("getNestedParam", ()=>{
         const testObj = {
             user: {
                 name: {
-                    type: 'text',
+                    type: "text",
                     required: true
                 },
                 email: {
-                    type: 'email'
+                    type: "email"
                 },
                 settings: {
                     theme: {
-                        type: 'text',
+                        type: "text",
                         enum: [
-                            'light',
-                            'dark'
+                            "light",
+                            "dark"
                         ]
                     },
                     notifications: {
-                        type: 'checkbox'
+                        type: "checkbox"
                     }
                 }
             },
             title: {
-                type: 'text',
-                default: 'Hello'
+                type: "text",
+                default: "Hello"
             }
         };
-        it('should get top-level properties', ()=>{
-            const result = getNestedParam(testObj, 'title');
+        it("should get top-level properties", ()=>{
+            const result = getNestedParam(testObj, "title");
             expect(result).toEqual({
-                type: 'text',
-                default: 'Hello'
+                type: "text",
+                default: "Hello"
             });
         });
-        it('should get nested properties', ()=>{
-            const result = getNestedParam(testObj, 'user.name');
+        it("should get nested properties", ()=>{
+            const result = getNestedParam(testObj, "user.name");
             expect(result).toEqual({
-                type: 'text',
+                type: "text",
                 required: true
             });
         });
-        it('should get deeply nested properties', ()=>{
-            const result = getNestedParam(testObj, 'user.settings.theme');
+        it("should get deeply nested properties", ()=>{
+            const result = getNestedParam(testObj, "user.settings.theme");
             expect(result).toEqual({
-                type: 'text',
+                type: "text",
                 enum: [
-                    'light',
-                    'dark'
+                    "light",
+                    "dark"
                 ]
             });
         });
-        it('should return undefined for non-existent paths', ()=>{
-            expect(getNestedParam(testObj, 'nonexistent')).toBeUndefined();
-            expect(getNestedParam(testObj, 'user.nonexistent')).toBeUndefined();
-            expect(getNestedParam(testObj, 'user.settings.nonexistent')).toBeUndefined();
+        it("should return undefined for non-existent paths", ()=>{
+            expect(getNestedParam(testObj, "nonexistent")).toBeUndefined();
+            expect(getNestedParam(testObj, "user.nonexistent")).toBeUndefined();
+            expect(getNestedParam(testObj, "user.settings.nonexistent")).toBeUndefined();
         });
-        it('should return undefined for invalid paths', ()=>{
-            expect(getNestedParam(testObj, 'title.invalid')).toBeUndefined();
-            expect(getNestedParam(testObj, 'user.name.invalid')).toBeUndefined();
+        it("should return undefined for invalid paths", ()=>{
+            expect(getNestedParam(testObj, "title.invalid")).toBeUndefined();
+            expect(getNestedParam(testObj, "user.name.invalid")).toBeUndefined();
         });
-        it('should handle empty path', ()=>{
-            const result = getNestedParam(testObj, '');
+        it("should handle empty path", ()=>{
+            const result = getNestedParam(testObj, "");
             expect(result).toBeUndefined(); // Empty string path returns undefined
         });
-        it('should handle paths with array values safely', ()=>{
+        it("should handle paths with array values safely", ()=>{
             const objWithArray = {
                 items: {
                     enum: [
-                        'a',
-                        'b',
-                        'c'
+                        "a",
+                        "b",
+                        "c"
                     ]
                 }
             };
-            const result = getNestedParam(objWithArray, 'items.enum');
+            const result = getNestedParam(objWithArray, "items.enum");
             expect(result).toEqual([
-                'a',
-                'b',
-                'c'
+                "a",
+                "b",
+                "c"
             ]); // Arrays are accessible as normal properties
         });
     });

package/dist/src/lib/navigation.d.ts

@@ -1,5 +1,5 @@
-import type { QueryParams } from 'next-intl/navigation';
-import type { RedirectType } from 'next/navigation';
+import type { RedirectType } from "next/navigation";
+import type { QueryParams } from "next-intl/navigation";
 declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     slot?: string | undefined | undefined;
     style?: import("react").CSSProperties | undefined;

package/dist/src/lib/navigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/lib/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpD,QAAA,MACE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAEJ,WAAW,gBACX,SAAS;;;;;cAmBgkyB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlB3n3B,WAAW;;;;;;;YACS,CAAC;AAEvB,QAAA,MAAM,QAAQ,GACZ,MACI,MAAM,GACN;IACE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,EACL,OAAO,YAAY,kBAKpB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/lib/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAKxD,QAAA,MACE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAEJ,WAAW,gBACX,SAAS;;;;;cAmBgkyB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlB3n3B,WAAW;;;;;;;YACS,CAAC;AAEvB,QAAA,MAAM,QAAQ,GACZ,MACI,MAAM,GACN;IACE,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,EACL,OAAO,YAAY,kBAKpB,CAAC;AAEF,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC"}

package/dist/src/lib/plugin.d.ts

@@ -1,11 +1,11 @@
-import type { ItemNavAdmin } from '../views/admin/layouts/sidebar/nav/item';
-interface AdminNavItem extends Pick<React.ComponentProps<typeof ItemNavAdmin>, 'href' | 'icon' | 'isOpenInNewTab'> {
+import type { ItemNavAdmin } from "../views/admin/layouts/sidebar/nav/item";
+interface AdminNavItem extends Pick<React.ComponentProps<typeof ItemNavAdmin>, "href" | "icon" | "isOpenInNewTab"> {
     id: string;
 }
 export interface BuildPluginReturn<P extends string = string> {
     admin?: {
         nav?: (AdminNavItem & {
-            items?: Omit<AdminNavItem, 'icon'>[];
+            items?: Omit<AdminNavItem, "icon">[];
         })[];
     };
     pluginId: P;

package/dist/src/lib/special-characters.js

@@ -1,4 +1,4 @@
-export const removeSpecialCharacters = (text, replaceSpace = true)=>text.trimStart().trimEnd().replace(/\s/g, replaceSpace ? '-' : ' ').normalize('NFD').replace(/\p{Diacritic}/gu, '').replace(/[#%&?^|'{}\\/]/g, '').replace(/ł/gi, 'l').replace(/@/g, '-at-').replace(/\./g, '-').replace(/-+/g, '-').trim();
+export const removeSpecialCharacters = (text, replaceSpace = true)=>text.trimStart().trimEnd().replace(/\s/g, replaceSpace ? "-" : " ").normalize("NFD").replace(/\p{Diacritic}/gu, "").replace(/[#%&?^|'{}\\/]/g, "").replace(/ł/gi, "l").replace(/@/g, "-at-").replace(/\./g, "-").replace(/-+/g, "-").trim();
 export const checkSpecialCharacters = (text)=>{
     return /^[a-z0-9-]+$/i.test(text);
 };

package/dist/src/lib/special-characters.test.js

@@ -1,56 +1,56 @@
 import { describe, expect, it } from "vitest";
 import { checkSpecialCharacters, removeSpecialCharacters } from "./special-characters.js";
-describe('removeSpecialCharacters', ()=>{
-    it('should remove diacritics and replace spaces with hyphens', ()=>{
-        expect(removeSpecialCharacters('héllo wörld')).toBe('hello-world');
+describe("removeSpecialCharacters", ()=>{
+    it("should remove diacritics and replace spaces with hyphens", ()=>{
+        expect(removeSpecialCharacters("héllo wörld")).toBe("hello-world");
     });
-    it('should keep spaces when replaceSpace is false', ()=>{
-        expect(removeSpecialCharacters('hello world', false)).toBe('hello world');
+    it("should keep spaces when replaceSpace is false", ()=>{
+        expect(removeSpecialCharacters("hello world", false)).toBe("hello world");
     });
-    it('should remove special characters', ()=>{
-        expect(removeSpecialCharacters('hello#world%123')).toBe('helloworld123');
+    it("should remove special characters", ()=>{
+        expect(removeSpecialCharacters("hello#world%123")).toBe("helloworld123");
     });
-    it('should replace @ with -at-', ()=>{
-        expect(removeSpecialCharacters('user@example.com')).toBe('user-at-example-com');
+    it("should replace @ with -at-", ()=>{
+        expect(removeSpecialCharacters("user@example.com")).toBe("user-at-example-com");
     });
-    it('should replace dots with hyphens', ()=>{
-        expect(removeSpecialCharacters('file.name.txt')).toBe('file-name-txt');
+    it("should replace dots with hyphens", ()=>{
+        expect(removeSpecialCharacters("file.name.txt")).toBe("file-name-txt");
     });
-    it('should replace Polish ł with l', ()=>{
-        expect(removeSpecialCharacters('Łódź')).toBe('lodz');
+    it("should replace Polish ł with l", ()=>{
+        expect(removeSpecialCharacters("Łódź")).toBe("lodz");
     });
-    it('should trim whitespace from start and end', ()=>{
-        expect(removeSpecialCharacters('  hello world  ')).toBe('hello-world');
+    it("should trim whitespace from start and end", ()=>{
+        expect(removeSpecialCharacters("  hello world  ")).toBe("hello-world");
     });
-    it('should handle empty string', ()=>{
-        expect(removeSpecialCharacters('')).toBe('');
+    it("should handle empty string", ()=>{
+        expect(removeSpecialCharacters("")).toBe("");
     });
-    it('should handle multiple special characters and spaces', ()=>{
-        expect(removeSpecialCharacters('Hello & World #123 {test}')).toBe('Hello-World-123-test');
+    it("should handle multiple special characters and spaces", ()=>{
+        expect(removeSpecialCharacters("Hello & World #123 {test}")).toBe("Hello-World-123-test");
     });
 });
-describe('checkSpecialCharacters', ()=>{
-    it('should return true for alphanumeric characters and hyphens', ()=>{
-        expect(checkSpecialCharacters('hello-world-123')).toBe(true);
+describe("checkSpecialCharacters", ()=>{
+    it("should return true for alphanumeric characters and hyphens", ()=>{
+        expect(checkSpecialCharacters("hello-world-123")).toBe(true);
     });
-    it('should return false for special characters', ()=>{
-        expect(checkSpecialCharacters('hello@world')).toBe(false);
+    it("should return false for special characters", ()=>{
+        expect(checkSpecialCharacters("hello@world")).toBe(false);
     });
-    it('should return false for spaces', ()=>{
-        expect(checkSpecialCharacters('hello world')).toBe(false);
+    it("should return false for spaces", ()=>{
+        expect(checkSpecialCharacters("hello world")).toBe(false);
     });
-    it('should return true for uppercase letters', ()=>{
-        expect(checkSpecialCharacters('HelloWorld')).toBe(true);
+    it("should return true for uppercase letters", ()=>{
+        expect(checkSpecialCharacters("HelloWorld")).toBe(true);
     });
-    it('should return true for numbers only', ()=>{
-        expect(checkSpecialCharacters('123')).toBe(true);
+    it("should return true for numbers only", ()=>{
+        expect(checkSpecialCharacters("123")).toBe(true);
     });
-    it('should return true for hyphens only', ()=>{
-        expect(checkSpecialCharacters('-')).toBe(true);
+    it("should return true for hyphens only", ()=>{
+        expect(checkSpecialCharacters("-")).toBe(true);
     });
-    it('should return false for other special characters', ()=>{
-        expect(checkSpecialCharacters('hello#world')).toBe(false);
-        expect(checkSpecialCharacters('test.com')).toBe(false);
-        expect(checkSpecialCharacters('user&name')).toBe(false);
+    it("should return false for other special characters", ()=>{
+        expect(checkSpecialCharacters("hello#world")).toBe(false);
+        expect(checkSpecialCharacters("test.com")).toBe(false);
+        expect(checkSpecialCharacters("user&name")).toBe(false);
     });
 });

package/dist/src/lib/utils.d.ts

@@ -1,3 +1,3 @@
-import { type ClassValue } from 'clsx';
+import { type ClassValue } from "clsx";
 export declare function cn(...inputs: ClassValue[]): string;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/tests/setup.d.ts

@@ -1,2 +1,2 @@
-import '@testing-library/react';
+import "@testing-library/react";
 //# sourceMappingURL=setup.d.ts.map

package/dist/src/views/admin/layouts/admin-layout.d.ts

@@ -1,4 +1,4 @@
-import type { VitNodeConfig } from '../../../vitnode.config';
+import type { VitNodeConfig } from "../../../vitnode.config";
 export interface AdminLayoutProps {
     children: React.ReactNode;
 }

package/dist/src/views/admin/layouts/admin-layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"admin-layout.d.ts","sourceRoot":"","sources":["../../../../../src/views/admin/layouts/admin-layout.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAQ7D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,WAAW,GAAU,8BAG/B,gBAAgB,GAAG;IACpB,aAAa,EAAE,aAAa,CAAC;CAC9B,4DAoDA,CAAC"}
+{"version":3,"file":"admin-layout.d.ts","sourceRoot":"","sources":["../../../../../src/views/admin/layouts/admin-layout.tsx"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAK7D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,WAAW,GAAU,8BAG/B,gBAAgB,GAAG;IACpB,aAAa,EAAE,aAAa,CAAC;CAC9B,4DAiDA,CAAC"}