@vitnode/core 1.2.0-canary.59 → 1.2.0-canary.61

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

@@ -1,98 +1 @@
-export function getDefaults(jsonSchema) {
-    if (!jsonSchema?.properties) {
-        return {};
-    }
-    const defaultValues = {};
-    // Iterate over each property in the schema
-    for(const key in jsonSchema.properties){
-        const prop = jsonSchema.properties[key];
-        // Case 1: The property has a 'default' key.
-        if (prop.default !== undefined) {
-            defaultValues[key] = prop.default;
-            continue; // Move to the next property
-        }
-        // Case 2: The property is a nested object. Recurse into it.
-        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) {
-                defaultValues[key] = nestedDefaults;
-            }
-        }
-    }
-    return defaultValues;
-}
-export function getZodInputParams(jsonSchema, parentRequired = []) {
-    // Base case: If there's no schema or properties, return an empty object.
-    if (!jsonSchema?.properties) {
-        return {};
-    }
-    const extractedParams = {};
-    const requiredFields = new Set(jsonSchema.required ?? parentRequired);
-    // Iterate over each property in the current schema level.
-    for(const key in jsonSchema.properties){
-        const prop = jsonSchema.properties[key];
-        const fieldParams = {};
-        // 1. Handle 'required' status
-        if (requiredFields.has(key)) {
-            fieldParams.required = true;
-        }
-        // 2. Handle standard string constraints
-        if (prop.minLength !== undefined) {
-            fieldParams.minLength = prop.minLength;
-        }
-        if (prop.maxLength !== undefined) {
-            fieldParams.maxLength = prop.maxLength;
-        }
-        if (prop.pattern !== undefined) {
-            fieldParams.pattern = prop.pattern;
-        }
-        if (prop.enum) {
-            fieldParams.enum = prop.enum;
-        }
-        // 3. Handle complex patterns from `allOf` (used for password)
-        if (prop.allOf) {
-            fieldParams.patterns = prop.allOf.map((p)=>p.pattern).filter(Boolean); // Filter out any undefined patterns
-        }
-        if (prop.description) {
-            fieldParams.description = prop.description;
-        }
-        // 4. Determine the input type based on schema type and format
-        switch(prop.type){
-            case "boolean":
-                fieldParams.type = "checkbox";
-                break;
-            case "integer":
-            case "number":
-                fieldParams.type = "number";
-                break;
-            case "string":
-                // Check format for special string types
-                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";
-                } else {
-                    fieldParams.type = "text";
-                }
-                break;
-        }
-        // 5. Handle nested objects by making a recursive call
-        if (prop.type === "object") {
-            // Pass the 'required' array from the nested object itself.
-            extractedParams[key] = getZodInputParams(prop, prop.required);
-        } else {
-            extractedParams[key] = fieldParams;
-        }
-    }
-    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 acc[key];
-        }
-        return undefined;
-    }, obj);
-}
+export function getDefaults(jsonSchema){if(!jsonSchema?.properties){return{}}const defaultValues={};for(const key in jsonSchema.properties){const prop=jsonSchema.properties[key];if(prop.default!==undefined){defaultValues[key]=prop.default;continue}if(prop.type==="object"&&prop.properties){const nestedDefaults=getDefaults(prop);if(Object.keys(nestedDefaults).length>0){defaultValues[key]=nestedDefaults}}}return defaultValues}export function getZodInputParams(jsonSchema,parentRequired=[]){if(!jsonSchema?.properties){return{}}const extractedParams={};const requiredFields=new Set(jsonSchema.required??parentRequired);for(const key in jsonSchema.properties){const prop=jsonSchema.properties[key];const fieldParams={};if(requiredFields.has(key)){fieldParams.required=true}if(prop.minLength!==undefined){fieldParams.minLength=prop.minLength}if(prop.maxLength!==undefined){fieldParams.maxLength=prop.maxLength}if(prop.pattern!==undefined){fieldParams.pattern=prop.pattern}if(prop.enum){fieldParams.enum=prop.enum}if(prop.allOf){fieldParams.patterns=prop.allOf.map(p=>p.pattern).filter(Boolean)}if(prop.description){fieldParams.description=prop.description}switch(prop.type){case"boolean":fieldParams.type="checkbox";break;case"integer":case"number":fieldParams.type="number";break;case"string":if(prop.format==="email"){fieldParams.type="email"}else if(key.toLowerCase().includes("password")){fieldParams.type="password"}else{fieldParams.type="text"}break}if(prop.type==="object"){extractedParams[key]=getZodInputParams(prop,prop.required)}else{extractedParams[key]=fieldParams}}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 acc[key]}return undefined},obj)}

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

@@ -1,336 +1 @@
-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", ()=>{
-            expect(getDefaults()).toEqual({});
-        });
-        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", ()=>{
-            const zodSchema = z.object({
-                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",
-                age: 25,
-                active: true
-            });
-        });
-        it("should handle nested Zod objects with defaults", ()=>{
-            const zodSchema = z.object({
-                user: z.object({
-                    name: z.string().default("Jane"),
-                    settings: z.object({
-                        theme: z.string().default("dark"),
-                        notifications: z.boolean().default(false)
-                    })
-                }),
-                title: z.string().default("Hello")
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getDefaults(jsonSchema);
-            expect(result).toEqual({
-                user: {
-                    name: "Jane",
-                    settings: {
-                        theme: "dark",
-                        notifications: false
-                    }
-                },
-                title: "Hello"
-            });
-        });
-        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")
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getDefaults(jsonSchema);
-            expect(result).toEqual({
-                title: "Hello"
-            });
-        });
-        it("should handle mixed properties with and without defaults", ()=>{
-            const zodSchema = z.object({
-                name: z.string().default("Test"),
-                email: z.string(),
-                age: z.number().default(30),
-                bio: z.string()
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getDefaults(jsonSchema);
-            expect(result).toEqual({
-                name: "Test",
-                age: 30
-            });
-        });
-    });
-    describe("getZodInputParams", ()=>{
-        it("should return empty object when no schema provided", ()=>{
-            expect(getZodInputParams()).toEqual({});
-        });
-        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", ()=>{
-            const zodSchema = z.object({
-                name: z.string().min(2).max(50).regex(/^[a-zA-Z]+$/).describe("User name")
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema, [
-                "name"
-            ]);
-            expect(result).toEqual({
-                name: {
-                    type: "text",
-                    minLength: 2,
-                    maxLength: 50,
-                    pattern: "^[a-zA-Z]+$",
-                    description: "User name",
-                    required: true
-                }
-            });
-        });
-        it("should handle email format from Zod schema", ()=>{
-            const zodSchema = z.object({
-                email: z.email().describe("Email address")
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema, [
-                "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
-        });
-        it("should infer password type from field name", ()=>{
-            const zodSchema = z.object({
-                password: z.string(),
-                confirmPassword: z.string(),
-                userPassword: z.string()
-            });
-            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);
-        });
-        it("should handle number and boolean types from Zod schema", ()=>{
-            const zodSchema = z.object({
-                age: z.number(),
-                count: z.number().int(),
-                active: z.boolean()
-            });
-            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);
-        });
-        it("should handle enum values from Zod schema", ()=>{
-            const zodSchema = z.object({
-                role: z.enum([
-                    "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("required", true);
-        });
-        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")
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema);
-            expect(result.password).toHaveProperty("type", "password");
-            expect(result.password).toHaveProperty("minLength", 8);
-        });
-        it("should handle nested objects from Zod schema", ()=>{
-            const zodSchema = z.object({
-                user: z.object({
-                    name: z.string(),
-                    email: z.email()
-                }),
-                settings: z.object({
-                    theme: z.enum([
-                        "light",
-                        "dark"
-                    ]),
-                    notifications: z.boolean()
-                })
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema, [
-                "user"
-            ]);
-            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", ()=>{
-            const zodSchema = z.object({
-                name: z.string(),
-                email: z.string(),
-                age: z.number().optional()
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema, [
-                "name",
-                "email"
-            ]);
-            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", ()=>{
-            const zodSchema = z.object({
-                name: z.string(),
-                email: z.string().optional(),
-                age: z.number().optional()
-            });
-            const jsonSchema = z.toJSONSchema(zodSchema);
-            const result = getZodInputParams(jsonSchema, [
-                "name"
-            ]);
-            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", ()=>{
-            const zodSchema = z.object({
-                status: z.union([
-                    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");
-        });
-        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");
-        });
-    });
-    describe("getNestedParam", ()=>{
-        const testObj = {
-            user: {
-                name: {
-                    type: "text",
-                    required: true
-                },
-                email: {
-                    type: "email"
-                },
-                settings: {
-                    theme: {
-                        type: "text",
-                        enum: [
-                            "light",
-                            "dark"
-                        ]
-                    },
-                    notifications: {
-                        type: "checkbox"
-                    }
-                }
-            },
-            title: {
-                type: "text",
-                default: "Hello"
-            }
-        };
-        it("should get top-level properties", ()=>{
-            const result = getNestedParam(testObj, "title");
-            expect(result).toEqual({
-                type: "text",
-                default: "Hello"
-            });
-        });
-        it("should get nested properties", ()=>{
-            const result = getNestedParam(testObj, "user.name");
-            expect(result).toEqual({
-                type: "text",
-                required: true
-            });
-        });
-        it("should get deeply nested properties", ()=>{
-            const result = getNestedParam(testObj, "user.settings.theme");
-            expect(result).toEqual({
-                type: "text",
-                enum: [
-                    "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 invalid paths", ()=>{
-            expect(getNestedParam(testObj, "title.invalid")).toBeUndefined();
-            expect(getNestedParam(testObj, "user.name.invalid")).toBeUndefined();
-        });
-        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", ()=>{
-            const objWithArray = {
-                items: {
-                    enum: [
-                        "a",
-                        "b",
-                        "c"
-                    ]
-                }
-            };
-            const result = getNestedParam(objWithArray, "items.enum");
-            expect(result).toEqual([
-                "a",
-                "b",
-                "c"
-            ]); // Arrays are accessible as normal properties
-        });
-    });
-});
+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",()=>{expect(getDefaults()).toEqual({})});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",()=>{const zodSchema=z.object({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",age:25,active:true})});it("should handle nested Zod objects with defaults",()=>{const zodSchema=z.object({user:z.object({name:z.string().default("Jane"),settings:z.object({theme:z.string().default("dark"),notifications:z.boolean().default(false)})}),title:z.string().default("Hello")});const jsonSchema=z.toJSONSchema(zodSchema);const result=getDefaults(jsonSchema);expect(result).toEqual({user:{name:"Jane",settings:{theme:"dark",notifications:false}},title:"Hello"})});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")});const jsonSchema=z.toJSONSchema(zodSchema);const result=getDefaults(jsonSchema);expect(result).toEqual({title:"Hello"})});it("should handle mixed properties with and without defaults",()=>{const zodSchema=z.object({name:z.string().default("Test"),email:z.string(),age:z.number().default(30),bio:z.string()});const jsonSchema=z.toJSONSchema(zodSchema);const result=getDefaults(jsonSchema);expect(result).toEqual({name:"Test",age:30})})});describe("getZodInputParams",()=>{it("should return empty object when no schema provided",()=>{expect(getZodInputParams()).toEqual({})});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",()=>{const zodSchema=z.object({name:z.string().min(2).max(50).regex(/^[a-zA-Z]+$/).describe("User name")});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema,["name"]);expect(result).toEqual({name:{type:"text",minLength:2,maxLength:50,pattern:"^[a-zA-Z]+$",description:"User name",required:true}})});it("should handle email format from Zod schema",()=>{const zodSchema=z.object({email:z.email().describe("Email address")});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema,["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")});it("should infer password type from field name",()=>{const zodSchema=z.object({password:z.string(),confirmPassword:z.string(),userPassword:z.string()});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)});it("should handle number and boolean types from Zod schema",()=>{const zodSchema=z.object({age:z.number(),count:z.number().int(),active:z.boolean()});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)});it("should handle enum values from Zod schema",()=>{const zodSchema=z.object({role:z.enum(["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("required",true)});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")});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema);expect(result.password).toHaveProperty("type","password");expect(result.password).toHaveProperty("minLength",8)});it("should handle nested objects from Zod schema",()=>{const zodSchema=z.object({user:z.object({name:z.string(),email:z.email()}),settings:z.object({theme:z.enum(["light","dark"]),notifications:z.boolean()})});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema,["user"]);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",()=>{const zodSchema=z.object({name:z.string(),email:z.string(),age:z.number().optional()});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema,["name","email"]);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",()=>{const zodSchema=z.object({name:z.string(),email:z.string().optional(),age:z.number().optional()});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema,["name"]);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",()=>{const zodSchema=z.object({status:z.union([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")});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")})});describe("getNestedParam",()=>{const testObj={user:{name:{type:"text",required:true},email:{type:"email"},settings:{theme:{type:"text",enum:["light","dark"]},notifications:{type:"checkbox"}}},title:{type:"text",default:"Hello"}};it("should get top-level properties",()=>{const result=getNestedParam(testObj,"title");expect(result).toEqual({type:"text",default:"Hello"})});it("should get nested properties",()=>{const result=getNestedParam(testObj,"user.name");expect(result).toEqual({type:"text",required:true})});it("should get deeply nested properties",()=>{const result=getNestedParam(testObj,"user.settings.theme");expect(result).toEqual({type:"text",enum:["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 invalid paths",()=>{expect(getNestedParam(testObj,"title.invalid")).toBeUndefined();expect(getNestedParam(testObj,"user.name.invalid")).toBeUndefined()});it("should handle empty path",()=>{const result=getNestedParam(testObj,"");expect(result).toBeUndefined()});it("should handle paths with array values safely",()=>{const objWithArray={items:{enum:["a","b","c"]}};const result=getNestedParam(objWithArray,"items.enum");expect(result).toEqual(["a","b","c"])})})});

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

@@ -1,21 +1,25 @@
 import type { QueryParams } from "next-intl/navigation";
 import type { RedirectType } from "next/navigation";
 declare const Link: import("react").ForwardRefExoticComponent<Omit<{
+    target?: import("react").HTMLAttributeAnchorTarget | undefined;
+    type?: string | undefined | undefined;
+    id?: string | undefined | undefined;
+    prefix?: string | undefined | undefined;
+    property?: string | undefined | undefined;
+    children?: import("react").ReactNode;
+    key?: import("react").Key | null | undefined;
+    replace?: boolean | undefined;
     slot?: string | undefined | undefined;
     style?: import("react").CSSProperties | undefined;
     title?: string | undefined | undefined;
     locale?: import("use-intl").Locale | undefined;
     onError?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
-    children?: import("react").ReactNode;
     ref?: import("react").Ref<HTMLAnchorElement> | undefined;
-    replace?: boolean | undefined;
-    prefix?: string | undefined | undefined;
-    key?: import("react").Key | null | undefined;
     as?: (string | import("url").UrlObject) | undefined;
     scroll?: boolean | undefined;
     shallow?: boolean | undefined;
     passHref?: boolean | undefined;
-    prefetch?: boolean | "auto" | null | "unstable_forceStale" | undefined;
+    prefetch?: boolean | "auto" | null | undefined;
     legacyBehavior?: boolean | undefined;
     onMouseEnter?: React.MouseEventHandler<HTMLAnchorElement> | undefined;
     onTouchStart?: React.TouchEventHandler<HTMLAnchorElement> | undefined;
@@ -27,8 +31,6 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     hrefLang?: string | undefined | undefined;
     media?: string | undefined | undefined;
     ping?: string | undefined | undefined;
-    target?: import("react").HTMLAttributeAnchorTarget | undefined;
-    type?: string | undefined | undefined;
     referrerPolicy?: import("react").HTMLAttributeReferrerPolicy | undefined;
     defaultChecked?: boolean | undefined | undefined;
     defaultValue?: string | number | readonly string[] | undefined;
@@ -44,7 +46,6 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     draggable?: (boolean | "true" | "false") | undefined;
     enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
     hidden?: boolean | undefined | undefined;
-    id?: string | undefined | undefined;
     lang?: string | undefined | undefined;
     nonce?: string | undefined | undefined;
     spellCheck?: (boolean | "true" | "false") | undefined;
@@ -56,7 +57,6 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     content?: string | undefined | undefined;
     datatype?: string | undefined | undefined;
     inlist?: any;
-    property?: string | undefined | undefined;
     rel?: string | undefined | undefined;
     resource?: string | undefined | undefined;
     rev?: string | undefined | undefined;
@@ -73,12 +73,14 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     results?: number | undefined | undefined;
     security?: string | undefined | undefined;
     unselectable?: "on" | "off" | undefined | undefined;
-    popover?: "" | "auto" | "manual" | undefined | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
     popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
     popoverTarget?: string | undefined | undefined;
     inert?: boolean | undefined | undefined;
     inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
     is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    part?: string | undefined | undefined;
     tw?: string | undefined;
     "aria-activedescendant"?: string | undefined | undefined;
     "aria-atomic"?: (boolean | "true" | "false") | undefined;
@@ -154,7 +156,7 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     onBlurCapture?: import("react").FocusEventHandler<HTMLAnchorElement> | undefined;
     onChange?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
     onChangeCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
-    onBeforeInput?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
+    onBeforeInput?: import("react").InputEventHandler<HTMLAnchorElement> | undefined;
     onBeforeInputCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
     onInput?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
     onInputCapture?: import("react").FormEventHandler<HTMLAnchorElement> | undefined;
@@ -203,8 +205,6 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     onProgressCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onRateChange?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onRateChangeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
-    onResize?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
-    onResizeCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onSeeked?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onSeekedCapture?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
     onSeeking?: import("react").ReactEventHandler<HTMLAnchorElement> | undefined;
@@ -282,6 +282,8 @@ declare const Link: import("react").ForwardRefExoticComponent<Omit<{
     onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLAnchorElement> | undefined;
     onScroll?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
     onScrollCapture?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
+    onScrollEnd?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
+    onScrollEndCapture?: import("react").UIEventHandler<HTMLAnchorElement> | undefined;
     onWheel?: import("react").WheelEventHandler<HTMLAnchorElement> | undefined;
     onWheelCapture?: import("react").WheelEventHandler<HTMLAnchorElement> | undefined;
     onAnimationStart?: import("react").AnimationEventHandler<HTMLAnchorElement> | 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;;;;;cAmBimyB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlB5p3B,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,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAKpD,QAAA,MACE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+DAEJ,WAAW,gBACX,SAAS;;;;;cAmBwryB,CAAC;;;;;;cAAuxC,CAAC;;;;;;cAAwxC,CAAC;;;;;GAlBnv3B,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/navigation.js

@@ -1,11 +1 @@
-import { createNavigation } from "next-intl/navigation";
-import { getLocale } from "next-intl/server";
-const { Link, redirect: redirectFromImport, usePathname, useRouter, getPathname } = createNavigation();
-const redirect = async (href, type)=>{
-    const locale = await getLocale();
-    redirectFromImport({
-        href,
-        locale
-    }, type);
-};
-export { getPathname, Link, redirect, usePathname, useRouter };
+import{createNavigation}from"next-intl/navigation";import{getLocale}from"next-intl/server";const{Link,redirect:redirectFromImport,usePathname,useRouter,getPathname}=createNavigation();const redirect=async(href,type)=>{const locale=await getLocale();redirectFromImport({href,locale},type)};export{getPathname,Link,redirect,usePathname,useRouter};

package/dist/src/lib/plugin.js

@@ -1,3 +1 @@
-export function buildPlugin(props) {
-    return props;
-}
+export function buildPlugin(props){return props}

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

@@ -1,4 +1 @@
-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);
-};
+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 @@
-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");
-    });
-    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 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 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 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");
-    });
-});
-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 spaces", ()=>{
-        expect(checkSpecialCharacters("hello world")).toBe(false);
-    });
-    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 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);
-    });
-});
+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")});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 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 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 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")})});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 spaces",()=>{expect(checkSpecialCharacters("hello world")).toBe(false)});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 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)})});

package/dist/src/lib/utils.js

@@ -1,5 +1 @@
-import { clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-export function cn(...inputs) {
-    return twMerge(clsx(inputs));
-}
+import{clsx}from"clsx";import{twMerge}from"tailwind-merge";export function cn(...inputs){return twMerge(clsx(inputs))}