@vitnode/core 1.2.0-canary.74 → 1.2.0-canary.76

package/dist/scripts/shared/file-utils.js

@@ -1,203 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { basename, dirname, extname, join, normalize, relative, resolve, sep, } from "node:path";
-const relativeImportRegex = /import\s+(?:(?:{[^}]*})|(?:[^{}\s,]*))?\s*(?:,\s*(?:{[^}]*}))?\s*from\s+['"]([./]+[^'"]*)['"]/g;
-const atImportRegex = /import\s+(?:(?:{[^}]*})|(?:[^{}\s,]*))?\s*(?:,\s*(?:{[^}]*}))?\s*from\s+['"](@\/[^'"]*)['"]/g;
-const dynamicAtImportRegex = /import\s*\(\s*['"](@\/[^'"]*)['"]\s*\)/g;
-const jsExtensionRegex = /\.(js|jsx|ts|tsx)$/;
-const pageFileRegex = /^page\.(tsx|ts|jsx|js)$/i;
-export const routeKey = (filePath, localeRoot) => {
-    const rel = relative(localeRoot, filePath);
-    const parts = rel.split(sep);
-    parts.pop();
-    const filtered = parts.filter(p => !p.startsWith("("));
-    return normalize(filtered.join("/"));
-};
-export const buildInitialRouteMap = (localeRoot) => {
-    const map = new Map();
-    const visit = (dir) => {
-        if (!existsSync(dir))
-            return;
-        for (const entry of readdirSync(dir, { withFileTypes: true })) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                visit(full);
-                continue;
-            }
-            if (pageFileRegex.test(entry.name)) {
-                const key = routeKey(full, localeRoot);
-                map.set(key, full);
-            }
-        }
-    };
-    visit(localeRoot);
-    return map;
-};
-export const transformFileImports = (content, pluginName) => {
-    let transformedContent = content.replace(relativeImportRegex, (match, importPath) => {
-        if (importPath.startsWith(".")) {
-            const cleanPath = importPath.replace(jsExtensionRegex, "");
-            const normalizedPath = cleanPath.replace(/^(?:\.\.\/)+/, "");
-            return match.replace(importPath, `${pluginName}/${normalizedPath}`);
-        }
-        return match;
-    });
-    transformedContent = transformedContent.replace(atImportRegex, (match, importPath) => {
-        const cleanPath = importPath
-            .replace(/^@\//, "")
-            .replace(jsExtensionRegex, "");
-        return match.replace(importPath, `${pluginName}/${cleanPath}`);
-    });
-    transformedContent = transformedContent.replace(dynamicAtImportRegex, (match, importPath) => {
-        const cleanPath = importPath
-            .replace(/^@\//, "")
-            .replace(jsExtensionRegex, "");
-        return match.replace(importPath, `${pluginName}/${cleanPath}`);
-    });
-    transformedContent = transformedContent.replace(/dynamic\s*\(\s*\(\s*=>\s*import\s*\(\s*['"](@\/[^'"]*)['"]\s*\)\s*\)\s*\)/g, (match, importPath) => {
-        const cleanPath = importPath
-            .replace(/^@\//, "")
-            .replace(jsExtensionRegex, "");
-        return match.replace(importPath, `${pluginName}/${cleanPath}`);
-    });
-    return transformedContent;
-};
-export function findRepoRoot(startPath) {
-    let currentPath = startPath;
-    while (currentPath !== resolve(currentPath, "..")) {
-        const turboConfigPath = join(currentPath, "turbo.json");
-        if (existsSync(turboConfigPath)) {
-            return currentPath;
-        }
-        currentPath = resolve(currentPath, "..");
-    }
-    const packagePath = join(startPath, "package.json");
-    if (existsSync(packagePath)) {
-        return startPath;
-    }
-    throw new Error("❌ Could not locate project root");
-}
-export function findLocaleRoot(repoRoot) {
-    const standalonePath = join(repoRoot, "src", "app", "[locale]");
-    if (existsSync(standalonePath)) {
-        return standalonePath;
-    }
-    const findLocaleDirectories = (searchDir) => {
-        const localeDirectories = [];
-        if (!existsSync(searchDir))
-            return localeDirectories;
-        const visit = (currentDir, depth = 0) => {
-            if (depth > 4)
-                return;
-            try {
-                const entries = readdirSync(currentDir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (!entry.isDirectory())
-                        continue;
-                    const fullPath = join(currentDir, entry.name);
-                    if (entry.name === "[locale]") {
-                        const parentPath = dirname(fullPath);
-                        if (parentPath.endsWith(join("src", "app"))) {
-                            localeDirectories.push(fullPath);
-                            continue;
-                        }
-                    }
-                    visit(fullPath, depth + 1);
-                }
-            }
-            catch (_error) {
-            }
-        };
-        visit(searchDir);
-        return localeDirectories;
-    };
-    const localeDirectories = findLocaleDirectories(repoRoot);
-    if (localeDirectories.length > 0) {
-        return localeDirectories[0];
-    }
-    const defaultAppDir = join(repoRoot, "apps", "docs", "src", "app", "[locale]");
-    return defaultAppDir;
-}
-export const getAllFiles = (dir) => {
-    const files = [];
-    if (!existsSync(dir))
-        return files;
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...getAllFiles(fullPath));
-        }
-        else {
-            files.push(fullPath);
-        }
-    }
-    return files;
-};
-export const isDirectoryEmpty = (dir) => {
-    if (!existsSync(dir))
-        return true;
-    const files = getAllFiles(dir);
-    return files.length === 0;
-};
-export const copyFile = (srcPath, destPath, pluginName, routeMap, localeRoot, repoRoot, verbose = true) => {
-    const fileName = basename(srcPath);
-    if (pageFileRegex.test(fileName)) {
-        const key = routeKey(destPath, localeRoot);
-        const existing = routeMap.get(key);
-        if (existing && existing !== destPath) {
-            if (verbose) {
-                console.log(`\x1b[31mSkipped duplicate page:\x1b[0m ${relative(repoRoot, destPath)} (collides with ${relative(repoRoot, existing)})`);
-            }
-            return;
-        }
-    }
-    try {
-        const destDir = dirname(destPath);
-        if (!existsSync(destDir)) {
-            mkdirSync(destDir, { recursive: true });
-        }
-        const ext = extname(srcPath);
-        if (pluginName && [".js", ".jsx", ".ts", ".tsx"].includes(ext)) {
-            const content = readFileSync(srcPath, "utf-8");
-            const transformedContent = transformFileImports(content, pluginName);
-            writeFileSync(destPath, transformedContent);
-        }
-        else {
-            copyFileSync(srcPath, destPath);
-        }
-        if (verbose) {
-            const srcAppIdx = srcPath.indexOf(join("src", "app"));
-            let shortSrc;
-            if (srcAppIdx !== -1) {
-                shortSrc = srcPath.substring(srcAppIdx);
-            }
-            else if (srcPath.startsWith(repoRoot)) {
-                shortSrc = relative(repoRoot, srcPath);
-            }
-            else {
-                shortSrc = srcPath;
-            }
-            const shortDest = destPath.startsWith(repoRoot)
-                ? relative(repoRoot, destPath)
-                : destPath;
-            console.log(`\x1b[32mCopied:\x1b[0m ${shortSrc} → ${shortDest}`);
-        }
-        if (pageFileRegex.test(basename(destPath))) {
-            const key = routeKey(destPath, localeRoot);
-            routeMap.set(key, destPath);
-        }
-    }
-    catch (error) {
-        console.error(`\x1b[31mError copying file:\x1b[0m ${srcPath}`, error);
-    }
-};
-export const copyDirectoryRecursive = (sourceDir, destinationDir, pluginName, routeMap, localeRoot, repoRoot, verbose = true) => {
-    if (!existsSync(sourceDir) || isDirectoryEmpty(sourceDir))
-        return;
-    const files = getAllFiles(sourceDir);
-    for (const srcFile of files) {
-        const relativePath = relative(sourceDir, srcFile);
-        const destFile = join(destinationDir, relativePath);
-        copyFile(srcFile, destFile, pluginName, routeMap, localeRoot, repoRoot, verbose);
-    }
-};

package/dist/src/components/form/fields/combobox.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=combobox.test.d.ts.map

package/dist/src/components/form/fields/combobox.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"combobox.test.d.ts","sourceRoot":"","sources":["../../../../../src/components/form/fields/combobox.test.tsx"],"names":[],"mappings":""}

package/dist/src/components/form/fields/combobox.test.js

@@ -1 +0,0 @@
-import{jsx as _jsx}from"react/jsx-runtime";import{QueryClient,QueryClientProvider}from"@tanstack/react-query";import{fireEvent,render,screen,waitFor}from"@testing-library/react";import{afterEach,describe,expect,it,vi}from"vitest";import{AutoFormCombobox}from"./combobox.js";vi.mock("next-intl",()=>({useTranslations:()=>key=>key}));vi.mock("@/components/ui/form",()=>({FormMessage:()=>null,useFormField:()=>({error:undefined,formDescriptionId:"form-item-description",formItemId:"form-item",formMessageId:"form-item-message"})}));afterEach(()=>{vi.useRealTimers()});const createField=(value=null)=>{return{value,onChange:vi.fn(),onBlur:vi.fn(),name:"field",ref:vi.fn()}};const renderWithClient=ui=>{const queryClient=new QueryClient({defaultOptions:{queries:{retry:false}}});return render(_jsx(QueryClientProvider,{client:queryClient,children:ui}))};describe("AutoFormCombobox",()=>{it("uses the translated default placeholder when no placeholder is provided",()=>{renderWithClient(_jsx(AutoFormCombobox,{field:createField(),otherProps:{enum:["option-one"],isOptional:false,"aria-invalid":false}}));expect(screen.getByPlaceholderText("select_option")).toBeTruthy()});it("renders label and placeholder for static options",()=>{renderWithClient(_jsx(AutoFormCombobox,{field:createField(),label:"Type",otherProps:{enum:["option-one","option-two"],isOptional:false,"aria-invalid":false},placeholder:"Pick a type"}));expect(screen.getByText("Type")).toBeTruthy();expect(screen.getByPlaceholderText("Pick a type")).toBeTruthy()});it("renders optional marker, labelRight and description",()=>{renderWithClient(_jsx(AutoFormCombobox,{description:"Choose the primary item type.",field:createField(),label:"Type",labelRight:_jsx("span",{children:"Admin only"}),otherProps:{enum:["option-one"],isOptional:true,"aria-invalid":false}}));expect(screen.getByText("Type")).toBeTruthy();expect(screen.getByText("optional")).toBeTruthy();expect(screen.getByText("Admin only")).toBeTruthy();expect(screen.getByText("Choose the primary item type.")).toBeTruthy()});it("passes disabled and invalid state to the single input",()=>{renderWithClient(_jsx(AutoFormCombobox,{disabled:true,field:createField(),otherProps:{enum:["option-one"],isOptional:false,"aria-invalid":true},placeholder:"Pick a type"}));const input=screen.getByPlaceholderText("Pick a type");expect(input.disabled).toBe(true);expect(input.getAttribute("aria-invalid")).toBe("true")});it("renders chips when multiple for static options",()=>{const{container}=renderWithClient(_jsx(AutoFormCombobox,{field:createField([]),label:"Tags",multiple:true,otherProps:{enum:["one","two"],isOptional:false,"aria-invalid":false}}));expect(container.querySelector("[data-slot='combobox-chips']")).toBeTruthy()});it("renders mapped labels for selected values",()=>{renderWithClient(_jsx(AutoFormCombobox,{field:createField(["option-one"]),labels:[{label:"Option One",value:"option-one"}],multiple:true,otherProps:{enum:["option-one"],isOptional:false,"aria-invalid":false}}));expect(screen.getByText("Option One")).toBeTruthy()});it("falls back to raw selected values when labels are missing",()=>{renderWithClient(_jsx(AutoFormCombobox,{field:createField(["unknown-option"]),multiple:true,otherProps:{enum:["unknown-option"],isOptional:false,"aria-invalid":false}}));expect(screen.getByText("unknown-option")).toBeTruthy()});it("calls onInputValueChange for static input",()=>{const onInputValueChange=vi.fn();renderWithClient(_jsx(AutoFormCombobox,{field:createField(),label:"Type",onInputValueChange:onInputValueChange,otherProps:{enum:["option-one"],isOptional:false,"aria-invalid":false},placeholder:"Pick a type"}));fireEvent.change(screen.getByPlaceholderText("Pick a type"),{target:{value:"opt"}});expect(onInputValueChange).toHaveBeenCalled()});it("calls field.onChange and onValueChange when a static option is selected",async()=>{const field=createField();const onValueChange=vi.fn();renderWithClient(_jsx(AutoFormCombobox,{field:field,onValueChange:onValueChange,otherProps:{enum:["option-one","option-two"],isOptional:false,"aria-invalid":false},placeholder:"Pick a type"}));const input=screen.getByPlaceholderText("Pick a type");fireEvent.focus(input);fireEvent.keyDown(input,{key:"ArrowDown"});fireEvent.keyDown(input,{key:"Enter"});await waitFor(()=>{expect(field.onChange).toHaveBeenCalledWith("option-one")});expect(onValueChange).toHaveBeenCalledWith("option-one",expect.anything())});it("loads async options and ignores multiple",async()=>{const fetchData=vi.fn().mockResolvedValue([{label:"Category",value:"1"}]);const{container}=renderWithClient(_jsx(AutoFormCombobox,{fetchData:fetchData,field:createField(),id:"categoryId",label:"Category",multiple:true,otherProps:{isOptional:false,"aria-invalid":false},searchPlaceholder:"Search categories"}));await waitFor(()=>{expect(fetchData).toHaveBeenCalledWith({search:""})});expect(screen.getByPlaceholderText("Search categories")).toBeTruthy();expect(container.querySelector("[data-slot='combobox-chips']")).toBeNull()});it("uses placeholder as async search placeholder fallback",async()=>{const fetchData=vi.fn().mockResolvedValue([]);renderWithClient(_jsx(AutoFormCombobox,{fetchData:fetchData,field:createField(),id:"categoryId",otherProps:{isOptional:false,"aria-invalid":false},placeholder:"Search from placeholder"}));await waitFor(()=>{expect(fetchData).toHaveBeenCalledWith({search:""})});expect(screen.getByPlaceholderText("Search from placeholder")).toBeTruthy()});it("forwards async input changes without refetching immediately",async()=>{const fetchData=vi.fn().mockResolvedValue([]);const onInputValueChange=vi.fn();renderWithClient(_jsx(AutoFormCombobox,{fetchData:fetchData,field:createField(),id:"categoryId",onInputValueChange:onInputValueChange,otherProps:{isOptional:false,"aria-invalid":false},searchPlaceholder:"Search categories"}));await waitFor(()=>{expect(fetchData).toHaveBeenCalledWith({search:""})});const input=screen.getByPlaceholderText("Search categories");fireEvent.input(input,{target:{value:"cat"}});expect(onInputValueChange).toHaveBeenCalledWith("cat",expect.anything());expect(fetchData).not.toHaveBeenCalledWith({search:"cat"})})});

package/dist/src/lib/api/get-next-cron-run-date.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=get-next-cron-run-date.test.d.ts.map

package/dist/src/lib/api/get-next-cron-run-date.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-next-cron-run-date.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/get-next-cron-run-date.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/api/get-next-cron-run-date.test.js

@@ -1 +0,0 @@
-import{describe,expect,it,vi}from"vitest";import{getNextCronRunDate}from"./get-next-cron-run-date.js";describe("getNextCronRunDate",()=>{it("should return the next run date for a valid cron schedule with lastRun null",()=>{const schedule="0 0 * * *";const lastRun=null;const result=getNextCronRunDate(schedule,lastRun);expect(result).toBeInstanceOf(Date);if(result){expect(result.getHours()).toBe(0);expect(result.getMinutes()).toBe(0)}});it("should return the next run date for a valid cron schedule with lastRun provided",()=>{const schedule="0 0 * * *";const lastRun=new Date("2023-01-01T12:00:00Z");const result=getNextCronRunDate(schedule,lastRun);expect(result).toBeInstanceOf(Date);if(result){expect(result.getHours()).toBe(0);expect(result.getMinutes()).toBe(0);expect(result.getTime()).toBeGreaterThan(lastRun.getTime())}});it("should return null for an invalid cron schedule",()=>{const schedule="invalid cron";const lastRun=null;const consoleSpy=vi.spyOn(console,"error").mockImplementation(()=>{});const result=getNextCronRunDate(schedule,lastRun);expect(result).toBeNull();expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("[VitNode]"),expect.any(Error));consoleSpy.mockRestore()});it("should handle cron schedules with specific times",()=>{const schedule="30 14 * * 1";const lastRun=new Date("2023-01-01T10:00:00Z");const result=getNextCronRunDate(schedule,lastRun);expect(result).toBeInstanceOf(Date);if(result){expect(result.getDay()).toBe(1);expect(result.getHours()).toBe(14);expect(result.getMinutes()).toBe(30)}});it("should return null when cron parsing throws an error",()=>{const schedule="99 99 99 99 99";const lastRun=null;const consoleSpy=vi.spyOn(console,"error").mockImplementation(()=>{});const result=getNextCronRunDate(schedule,lastRun);expect(result).toBeNull();expect(consoleSpy).toHaveBeenCalled();consoleSpy.mockRestore()})});

package/dist/src/lib/api/should-cron-job-run.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=should-cron-job-run.test.d.ts.map

package/dist/src/lib/api/should-cron-job-run.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"should-cron-job-run.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/should-cron-job-run.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/api/should-cron-job-run.test.js

@@ -1 +0,0 @@
-import{beforeEach,describe,expect,it,vi}from"vitest";import{shouldCronJobRun}from"./should-cron-job-run.js";describe("shouldCronJobRun",()=>{beforeEach(()=>{vi.clearAllMocks()});describe("valid cron schedules",()=>{it("should return true when job has never run (lastRun is null)",()=>{const schedule="0 * * * *";const lastRun=null;const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true)});it("should return true when enough time has passed since last run",()=>{const schedule="0 * * * *";const lastRun=new Date("2024-01-01T10:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should return false when not enough time has passed since last run",()=>{const schedule="0 * * * *";const lastRun=new Date("2024-01-01T11:30:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T11:45:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(false);vi.useRealTimers()});it("should handle daily job correctly",()=>{const schedule="0 9 * * *";const lastRun=new Date("2024-01-01T09:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-02T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle weekly job correctly",()=>{const schedule="0 9 * * 1";const lastRun=new Date("2024-01-01T09:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-08T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle monthly job correctly",()=>{const schedule="0 9 1 * *";const lastRun=new Date("2024-01-01T09:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-02-01T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle every minute job correctly",()=>{const schedule="* * * * *";const lastRun=new Date("2024-01-01T10:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T10:01:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle every 5 minutes job correctly",()=>{const schedule="*/5 * * * *";const lastRun=new Date("2024-01-01T10:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T10:03:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(false);vi.setSystemTime(new Date("2024-01-01T10:05:00Z"));const result2=shouldCronJobRun(schedule,lastRun);expect(result2).toBe(true);vi.useRealTimers()});it("should handle complex cron expressions",()=>{const schedule="0 9-17 * * 1-5";const lastRun=new Date("2024-01-01T09:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()})});describe("invalid cron schedules",()=>{it("should return false and log error for invalid cron schedule",()=>{const consoleErrorSpy=vi.spyOn(console,"error").mockImplementation(()=>{});const schedule="invalid cron";const lastRun=null;const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(false);expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[VitNode]")&&expect.stringContaining("Error parsing schedule")&&expect.stringContaining("invalid cron"),expect.any(Error));consoleErrorSpy.mockRestore()});it("should return false for malformed cron expression",()=>{const consoleErrorSpy=vi.spyOn(console,"error").mockImplementation(()=>{});const schedule="60 * * * *";const lastRun=null;const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(false);expect(consoleErrorSpy).toHaveBeenCalled();consoleErrorSpy.mockRestore()});it("should return true for empty cron schedule (parsed as valid)",()=>{const schedule="";const lastRun=null;const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true)})});describe("edge cases",()=>{it("should handle lastRun being exactly at the next scheduled time",()=>{const schedule="0 * * * *";const lastRun=new Date("2024-01-01T10:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle lastRun being in the future (clock skew)",()=>{const schedule="0 * * * *";const lastRun=new Date("2024-01-01T12:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(false);vi.useRealTimers()});it("should handle lastRun being epoch (new Date(0))",()=>{const schedule="0 * * * *";const lastRun=new Date(0);vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle yearly cron job",()=>{const schedule="0 0 1 1 *";const lastRun=new Date("2023-01-01T00:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T01:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle specific day of month with month",()=>{const schedule="0 12 15 6 *";const lastRun=new Date("2023-06-15T12:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-06-15T13:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()})});describe("timezone handling",()=>{it("should work with different timezone dates",()=>{const schedule="0 9 * * *";const lastRun=new Date("2024-01-01T09:00:00+05:00");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-02T04:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()})});describe("performance and boundary conditions",()=>{it("should handle very old lastRun dates",()=>{const schedule="0 * * * *";const lastRun=new Date("1970-01-01T00:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()});it("should handle leap year considerations",()=>{const schedule="0 0 29 2 *";const lastRun=new Date("2020-02-29T00:00:00Z");vi.useFakeTimers();vi.setSystemTime(new Date("2024-02-29T01:00:00Z"));const result=shouldCronJobRun(schedule,lastRun);expect(result).toBe(true);vi.useRealTimers()})})});

package/dist/src/lib/api/validate-cron-schedule.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=validate-cron-schedule.test.d.ts.map

package/dist/src/lib/api/validate-cron-schedule.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"validate-cron-schedule.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/api/validate-cron-schedule.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/api/validate-cron-schedule.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{validateCronSchedule}from"./validate-cron-schedule.js";describe("validateCronSchedule",()=>{describe("valid 5-field cron expressions",()=>{it("should validate wildcard expression",()=>{expect(validateCronSchedule("* * * * *")).toBe(true)});it("should validate specific time expressions",()=>{expect(validateCronSchedule("0 0 * * *")).toBe(true);expect(validateCronSchedule("30 14 * * 1")).toBe(true);expect(validateCronSchedule("0 0 1 * *")).toBe(true);expect(validateCronSchedule("0 0 1 1 *")).toBe(true);expect(validateCronSchedule("15 10 * * 5")).toBe(true)});it("should validate step expressions",()=>{expect(validateCronSchedule("*/5 * * * *")).toBe(true);expect(validateCronSchedule("*/15 * * * *")).toBe(true);expect(validateCronSchedule("0 */2 * * *")).toBe(true);expect(validateCronSchedule("0 0 */3 * *")).toBe(true);expect(validateCronSchedule("0-30/5 * * * *")).toBe(true)});it("should validate range expressions",()=>{expect(validateCronSchedule("0 9-17 * * *")).toBe(true);expect(validateCronSchedule("0 0 1-15 * *")).toBe(true);expect(validateCronSchedule("0 0 * 1-6 *")).toBe(true);expect(validateCronSchedule("0 0 * * 1-5")).toBe(true)});it("should validate list expressions",()=>{expect(validateCronSchedule("0 0,12 * * *")).toBe(true);expect(validateCronSchedule("0 0 1,15 * *")).toBe(true);expect(validateCronSchedule("0 0 * * 1,3,5")).toBe(true);expect(validateCronSchedule("0 9,12,15 * * *")).toBe(true)});it("should validate complex expressions",()=>{expect(validateCronSchedule("0-30/5 9-17 * * 1-5")).toBe(true);expect(validateCronSchedule("0 0,12 1,15 * *")).toBe(true);expect(validateCronSchedule("*/10 */2 * * *")).toBe(true)});it("should validate weekday 0 and 7 (both Sunday)",()=>{expect(validateCronSchedule("0 0 * * 0")).toBe(true);expect(validateCronSchedule("0 0 * * 7")).toBe(true)});it("should validate edge cases",()=>{expect(validateCronSchedule("59 23 31 12 7")).toBe(true);expect(validateCronSchedule("0 0 1 1 0")).toBe(true)})});describe("valid 6-field cron expressions (with seconds)",()=>{it("should validate wildcard expression with seconds",()=>{expect(validateCronSchedule("* * * * * *")).toBe(true)});it("should validate specific time expressions with seconds",()=>{expect(validateCronSchedule("0 0 0 * * *")).toBe(true);expect(validateCronSchedule("30 30 14 * * 1")).toBe(true);expect(validateCronSchedule("0 0 0 1 * *")).toBe(true)});it("should validate step expressions with seconds",()=>{expect(validateCronSchedule("*/5 * * * * *")).toBe(true);expect(validateCronSchedule("0 */5 * * * *")).toBe(true);expect(validateCronSchedule("*/30 0 * * * *")).toBe(true)});it("should validate range expressions with seconds",()=>{expect(validateCronSchedule("0-30 0 9-17 * * *")).toBe(true)});it("should validate list expressions with seconds",()=>{expect(validateCronSchedule("0,30 0 0,12 * * *")).toBe(true)})});describe("invalid cron expressions",()=>{it("should reject empty or non-string input",()=>{expect(validateCronSchedule("")).toBe(false);expect(validateCronSchedule("   ")).toBe(false);expect(validateCronSchedule(null)).toBe(false);expect(validateCronSchedule(undefined)).toBe(false);expect(validateCronSchedule(123)).toBe(false)});it("should reject wrong number of fields",()=>{expect(validateCronSchedule("* * *")).toBe(false);expect(validateCronSchedule("* * * *")).toBe(false);expect(validateCronSchedule("* * * * * * *")).toBe(false);expect(validateCronSchedule("* * * * * * * *")).toBe(false)});it("should reject invalid characters",()=>{expect(validateCronSchedule("a * * * *")).toBe(false);expect(validateCronSchedule("* b * * *")).toBe(false);expect(validateCronSchedule("* * c * *")).toBe(false);expect(validateCronSchedule("@ # $ % ^")).toBe(false);expect(validateCronSchedule("invalid cron")).toBe(false)});it("should reject out-of-range values",()=>{expect(validateCronSchedule("60 * * * *")).toBe(false);expect(validateCronSchedule("* 24 * * *")).toBe(false);expect(validateCronSchedule("* * 32 * *")).toBe(false);expect(validateCronSchedule("* * 0 * *")).toBe(false);expect(validateCronSchedule("* * * 13 *")).toBe(false);expect(validateCronSchedule("* * * 0 *")).toBe(false);expect(validateCronSchedule("* * * * 8")).toBe(false);expect(validateCronSchedule("-1 * * * *")).toBe(false)});it("should reject out-of-range values in 6-field format",()=>{expect(validateCronSchedule("60 * * * * *")).toBe(false);expect(validateCronSchedule("-1 * * * * *")).toBe(false)});it("should reject invalid ranges",()=>{expect(validateCronSchedule("10-5 * * * *")).toBe(false);expect(validateCronSchedule("* 20-10 * * *")).toBe(false);expect(validateCronSchedule("* * 60-70 * *")).toBe(false);expect(validateCronSchedule("0-60 * * * *")).toBe(false)});it("should reject invalid steps",()=>{expect(validateCronSchedule("*/0 * * * *")).toBe(false);expect(validateCronSchedule("*/-1 * * * *")).toBe(false);expect(validateCronSchedule("*/60 * * * *")).toBe(false);expect(validateCronSchedule("*/abc * * * *")).toBe(false);expect(validateCronSchedule("* */25 * * *")).toBe(false)});it("should reject invalid lists",()=>{expect(validateCronSchedule("0,60 * * * *")).toBe(false);expect(validateCronSchedule("* 0,24 * * *")).toBe(false);expect(validateCronSchedule("a,b,c * * * *")).toBe(false);expect(validateCronSchedule(",, * * * *")).toBe(false)});it("should reject malformed expressions",()=>{expect(validateCronSchedule("1--5 * * * *")).toBe(false);expect(validateCronSchedule("1//5 * * * *")).toBe(false);expect(validateCronSchedule("1- * * * *")).toBe(false);expect(validateCronSchedule("-5 * * * *")).toBe(false);expect(validateCronSchedule("1/ * * * *")).toBe(false);expect(validateCronSchedule("/5 * * * *")).toBe(false)})});describe("edge cases",()=>{it("should handle extra whitespace",()=>{expect(validateCronSchedule("  * * * * *  ")).toBe(true);expect(validateCronSchedule("0  0  *  *  *")).toBe(true)});it("should reject mixed valid and invalid fields",()=>{expect(validateCronSchedule("0 0 * * invalid")).toBe(false);expect(validateCronSchedule("0 25 * * *")).toBe(false);expect(validateCronSchedule("* * * * * 60")).toBe(false)})})});

package/dist/src/lib/colors.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=colors.test.d.ts.map

package/dist/src/lib/colors.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"colors.test.d.ts","sourceRoot":"","sources":["../../../src/lib/colors.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/colors.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{checkColorType,convertColor,getHSLFromString,getStringFromHSL}from"./colors.js";describe("convertColor",()=>{describe("hslToHex",()=>{it("should convert HSL to hex correctly",()=>{const hsl={h:0,s:100,l:50};expect(convertColor.hslToHex(hsl)).toBe("ff0000");const hsl2={h:120,s:100,l:50};expect(convertColor.hslToHex(hsl2)).toBe("00ff00");const hsl3={h:240,s:100,l:50};expect(convertColor.hslToHex(hsl3)).toBe("0000ff")})});describe("hexToHSL",()=>{it("should convert 6-digit hex to HSL correctly",()=>{expect(convertColor.hexToHSL("#ff0000")).toEqual({h:0,s:100,l:50});expect(convertColor.hexToHSL("#00ff00")).toEqual({h:120,s:100,l:50});expect(convertColor.hexToHSL("#0000ff")).toEqual({h:240,s:100,l:50})});it("should convert 3-digit hex to HSL correctly",()=>{expect(convertColor.hexToHSL("#f00")).toEqual({h:0,s:100,l:50});expect(convertColor.hexToHSL("#0f0")).toEqual({h:120,s:100,l:50});expect(convertColor.hexToHSL("#00f")).toEqual({h:240,s:100,l:50})});it("should return undefined for invalid hex values",()=>{expect(convertColor.hexToHSL("#xyz")).toBeUndefined();expect(convertColor.hexToHSL("#12")).toBeUndefined();expect(convertColor.hexToHSL("invalid")).toBeUndefined()})});describe("RGBToHSL",()=>{it("should convert RGB to HSL correctly",()=>{expect(convertColor.RGBToHSL(255,0,0)).toEqual({h:0,s:100,l:50});expect(convertColor.RGBToHSL(0,255,0)).toEqual({h:120,s:100,l:50});expect(convertColor.RGBToHSL(0,0,255)).toEqual({h:240,s:100,l:50});expect(convertColor.RGBToHSL(255,255,255)).toEqual({h:0,s:0,l:100});expect(convertColor.RGBToHSL(0,0,0)).toEqual({h:0,s:0,l:0})})});describe("hslToRgb",()=>{it("should convert HSL to RGB correctly",()=>{expect(convertColor.hslToRgb(0,100,50)).toEqual({r:"ff",g:"00",b:"00"});expect(convertColor.hslToRgb(120,100,50)).toEqual({r:"00",g:"ff",b:"00"});expect(convertColor.hslToRgb(240,100,50)).toEqual({r:"00",g:"00",b:"ff"})})})});describe("checkColorType",()=>{it("should identify hex colors correctly",()=>{expect(checkColorType("#fff")).toBe("hex");expect(checkColorType("#ffffff")).toBe("hex");expect(checkColorType("#FF0000")).toBe("hex")});it("should identify HSL colors correctly",()=>{expect(checkColorType("hsl(0, 100%, 50%)")).toBe("hsl");expect(checkColorType("hsl(120, 60%, 70%)")).toBe("hsl")});it("should identify RGB colors correctly",()=>{expect(checkColorType("rgb(255, 0, 0)")).toBe("rgb");expect(checkColorType("rgb(255 0 0)")).toBe("rgb")});it("should return null for invalid colors",()=>{expect(checkColorType("invalid")).toBeNull();expect(checkColorType("rgb(300, 0, 0)")).toBeNull();expect(checkColorType("hsl(400, 100%, 50%)")).toBeNull()})});describe("getHSLFromString",()=>{it("should parse valid HSL strings correctly",()=>{expect(getHSLFromString("hsl(0, 100%, 50%)")).toEqual({h:0,s:100,l:50});expect(getHSLFromString("hsl(120, 60%, 70%)")).toEqual({h:120,s:60,l:70})});it("should return null for invalid HSL strings",()=>{expect(getHSLFromString("invalid")).toBeNull();expect(getHSLFromString("rgb(255, 0, 0)")).toBeNull();expect(getHSLFromString("hsl(400, 100%, 50%")).toBeNull()})});describe("getStringFromHSL",()=>{it("should format HSL color object to string correctly",()=>{expect(getStringFromHSL({h:0,s:100,l:50})).toBe("hsl(0, 100%, 50%)");expect(getStringFromHSL({h:120,s:60,l:70})).toBe("hsl(120, 60%, 70%)");expect(getStringFromHSL({h:240,s:50,l:30})).toBe("hsl(240, 50%, 30%)")})});

package/dist/src/lib/fetcher/cookie-from-string-to-object.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cookie-from-string-to-object.test.d.ts.map

package/dist/src/lib/fetcher/cookie-from-string-to-object.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cookie-from-string-to-object.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/fetcher/cookie-from-string-to-object.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/fetcher/cookie-from-string-to-object.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{cookieFromStringToObject}from"./cookie-from-string-to-object.js";describe("cookieFromStringToObject",()=>{it("should parse a simple cookie string",()=>{const cookies=["token=abc123; Path=/; HttpOnly"];const result=cookieFromStringToObject(cookies);expect(result).toEqual([{token:"abc123",Path:"/",HttpOnly:true}])});it("should parse multiple cookie attributes",()=>{const cookies=["sessionId=xyz789; Domain=example.com; Path=/; HttpOnly; Secure; SameSite=strict; Expires=Wed, 21 Oct 2025 07:28:00 GMT"];const result=cookieFromStringToObject(cookies);expect(result).toEqual([{sessionId:"xyz789",Domain:"example.com",Path:"/",HttpOnly:true,Secure:true,SameSite:"strict",Expires:"Wed, 21 Oct 2025 07:28:00 GMT"}])});it("should handle multiple cookies",()=>{const cookies=["token=abc123; Path=/; HttpOnly","theme=dark; Path=/; SameSite=lax"];const result=cookieFromStringToObject(cookies);expect(result).toEqual([{token:"abc123",Path:"/",HttpOnly:true},{theme:"dark",Path:"/",SameSite:"lax"}])});it("should handle URL encoded values",()=>{const cookies=["data=hello%20world; Path=/"];const result=cookieFromStringToObject(cookies);expect(result).toEqual([{data:"hello world",Path:"/"}])});it("should handle boolean flags without values",()=>{const cookies=["token=123; HttpOnly; Secure"];const result=cookieFromStringToObject(cookies);expect(result).toEqual([{token:"123",HttpOnly:true,Secure:true}])})});

package/dist/src/lib/fetcher/helpers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=helpers.test.d.ts.map

package/dist/src/lib/fetcher/helpers.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/fetcher/helpers.test.ts"],"names":[],"mappings":""}

package/dist/src/lib/fetcher/helpers.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{buildSearchParams}from"./helpers.js";describe("buildSearchParams",()=>{it("should handle empty query object",()=>{const params=buildSearchParams({});expect(params.toString()).toBe("")});it("should handle single string values",()=>{const params=buildSearchParams({key:"value"});expect(params.toString()).toBe("key=value")});it("should handle multiple string values",()=>{const params=buildSearchParams({key1:"value1",key2:"value2"});expect(params.toString()).toBe("key1=value1&key2=value2")});it("should handle array values",()=>{const params=buildSearchParams({key:["value1","value2"]});expect(params.toString()).toBe("key=value1&key=value2")});it("should skip undefined values",()=>{const params=buildSearchParams({key1:"value1",key2:undefined});expect(params.toString()).toBe("key1=value1")})});

package/dist/src/lib/helpers/auto-form.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=auto-form.test.d.ts.map

package/dist/src/lib/helpers/auto-form.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-form.test.d.ts","sourceRoot":"","sources":["../../../../src/lib/helpers/auto-form.test.ts"],"names":[],"mappings":""}

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

@@ -1 +0,0 @@
-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()).min(2).max(5),guests:z.array(z.object({name:z.string().min(2),email:z.email()}))});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema);expect(result).toHaveProperty("tags");expect(result.tags).toEqual({required:true,minItems:2,maxItems:5,itemParams:{"":{type:"text"}}});expect(result).toHaveProperty("guests");expect(result.guests).toEqual({required:true,itemParams:{name:{type:"text",required:true,minLength:2},email:{type:"email",required:true,pattern:"^(?!\\.)(?!.*\\.\\.)([A-Za-z0-9_'+\\-\\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\\-]*\\.)+[A-Za-z]{2,}$"}}})});it("should handle nested array types from Zod schema",()=>{const zodSchema=z.object({nestedGuests:z.array(z.array(z.string().min(2))).min(1).max(3)});const jsonSchema=z.toJSONSchema(zodSchema);const result=getZodInputParams(jsonSchema);expect(result).toHaveProperty("nestedGuests");expect(result.nestedGuests).toEqual({required:true,minItems:1,maxItems:3,itemParams:{"":{itemParams:{"":{type:"text",minLength:2}}}}})})});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"},guests:{itemParams:{name:{type:"text",required:true}}}};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 missing array params",()=>{const result=getNestedParam(testObj,"guests.itemParams.unknown");expect(result).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 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/special-characters.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=special-characters.test.d.ts.map

package/dist/src/lib/special-characters.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"special-characters.test.d.ts","sourceRoot":"","sources":["../../../src/lib/special-characters.test.ts"],"names":[],"mappings":""}

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

@@ -1 +0,0 @@
-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/tiptap/toolbar/actions/bold-action.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bold-action.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/tiptap/toolbar/actions/bold-action.tsx"],"names":[],"mappings":""}