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

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

@@ -12,7 +12,7 @@ export function getDefaults(jsonSchema) {
             continue; // Move to the next property
         }
         // Case 2: The property is a nested object. Recurse into it.
-        if (prop.type === 'object' && prop.properties) {
+        if (prop.type === "object" && prop.properties) {
             const nestedDefaults = getDefaults(prop);
             // Only add the nested object if it contains default values.
             if (Object.keys(nestedDefaults).length > 0) {
@@ -22,6 +22,7 @@ export function getDefaults(jsonSchema) {
     }
     return defaultValues;
 }
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: <it's complex and needs to be>
 export function getZodInputParams(jsonSchema, parentRequired = []) {
     // Base case: If there's no schema or properties, return an empty object.
     if (!jsonSchema?.properties) {
@@ -59,27 +60,27 @@ export function getZodInputParams(jsonSchema, parentRequired = []) {
         }
         // 4. Determine the input type based on schema type and format
         switch(prop.type){
-            case 'boolean':
-                fieldParams.type = 'checkbox';
+            case "boolean":
+                fieldParams.type = "checkbox";
                 break;
-            case 'integer':
-            case 'number':
-                fieldParams.type = 'number';
+            case "integer":
+            case "number":
+                fieldParams.type = "number";
                 break;
-            case 'string':
+            case "string":
                 // Check format for special string types
-                if (prop.format === 'email') {
-                    fieldParams.type = 'email';
-                } else if (key.toLowerCase().includes('password')) {
+                if (prop.format === "email") {
+                    fieldParams.type = "email";
+                } else if (key.toLowerCase().includes("password")) {
                     // Infer password type by key name for better UX
-                    fieldParams.type = 'password';
+                    fieldParams.type = "password";
                 } else {
-                    fieldParams.type = 'text';
+                    fieldParams.type = "text";
                 }
                 break;
         }
         // 5. Handle nested objects by making a recursive call
-        if (prop.type === 'object') {
+        if (prop.type === "object") {
             // Pass the 'required' array from the nested object itself.
             extractedParams[key] = getZodInputParams(prop, prop.required);
         } else {
@@ -89,8 +90,8 @@ export function getZodInputParams(jsonSchema, parentRequired = []) {
     return extractedParams;
 }
 export function getNestedParam(obj, path) {
-    return path.split('.').reduce((acc, key)=>{
-        if (acc && typeof acc === 'object' && !Array.isArray(acc) && key in acc) {
+    return path.split(".").reduce((acc, key)=>{
+        if (acc && typeof acc === "object" && !Array.isArray(acc) && key in acc) {
             return acc[key];
         }
         return undefined;

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);
 };