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

package/src/routes/main/files/page.tsx

@@ -0,0 +1,50 @@
+import { getTranslations } from "next-intl/server";
+import dynamic from "next/dynamic";
+import { notFound } from "next/navigation";
+import React from "react";
+
+import { I18nProvider } from "@/components/i18n-provider";
+import { DataTableSkeleton } from "@/components/table/data-table";
+import { HeaderContent } from "@/components/ui/header-content";
+import { getSessionApi } from "@/lib/api/get-session-api";
+
+const MyFilesTableView = dynamic(async () =>
+  import("@/views/files/my-files-table-view").then(module => ({
+    default: module.MyFilesTableView,
+  })),
+);
+
+export const generateMetadata = async () => {
+  const t = await getTranslations("core.files");
+
+  return {
+    title: t("title"),
+    description: t("desc"),
+    robots: { index: false, follow: false },
+  };
+};
+
+export default async function Page(
+  props: React.ComponentProps<typeof MyFilesTableView>,
+) {
+  const [t, session] = await Promise.all([
+    getTranslations("core.files"),
+    getSessionApi(),
+  ]);
+
+  if (!session.user) {
+    notFound();
+  }
+
+  return (
+    <I18nProvider namespaces={["core.files"]}>
+      <div className="container mx-auto space-y-6 p-4">
+        <HeaderContent desc={t("desc")} h1={t("title")} />
+
+        <React.Suspense fallback={<DataTableSkeleton columns={7} />}>
+          <MyFilesTableView {...props} />
+        </React.Suspense>
+      </div>
+    </I18nProvider>
+  );
+}

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "**/*.test.ts", "**/*.test.tsx"]
+}

package/dist/scripts/get-config.d.ts

@@ -1,7 +0,0 @@
-import type { VitNodeApiConfig, VitNodeConfig } from "../src/vitnode.config.js";
-type ConfigType<T extends "api.config" | "config"> = T extends "config" ? VitNodeConfig : VitNodeApiConfig;
-export declare const getConfig: <T extends "api.config" | "config">({ type, }: {
-    type?: T;
-}) => Promise<ConfigType<T>>;
-export {};
-//# sourceMappingURL=get-config.d.ts.map

package/dist/scripts/get-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-config.d.ts","sourceRoot":"","sources":["../../scripts/get-config.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEhF,KAAK,UAAU,CAAC,CAAC,SAAS,YAAY,GAAG,QAAQ,IAAI,CAAC,SAAS,QAAQ,GACnE,aAAa,GACb,gBAAgB,CAAC;AAoDrB,eAAO,MAAM,SAAS,GAAU,CAAC,SAAS,YAAY,GAAG,QAAQ,EAAE,WAEhE;IACD,IAAI,CAAC,EAAE,CAAC,CAAC;CACV,KAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAoCxB,CAAC"}

package/dist/scripts/plugin.d.ts

@@ -1,4 +0,0 @@
-export declare const processPlugin: ({ initMessage }: {
-    initMessage: string;
-}) => void;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/scripts/plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../scripts/plugin.ts"],"names":[],"mappings":"AAoUA,eAAO,MAAM,aAAa,GAAI,iBAAiB;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,SAqDrE,CAAC"}

package/dist/scripts/prepare-database.d.ts

@@ -1,8 +0,0 @@
-export declare const generateDatabaseMigrations: () => Promise<void>;
-export declare const runMigrations: () => Promise<void>;
-export declare const initialDataForDatabase: () => Promise<void>;
-export declare const prepareDatabase: ({ initMessage, flag, }: {
-    flag: string;
-    initMessage: string;
-}) => Promise<never>;
-//# sourceMappingURL=prepare-database.d.ts.map

package/dist/scripts/prepare-database.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepare-database.d.ts","sourceRoot":"","sources":["../../scripts/prepare-database.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B,qBAQtC,CAAC;AAEF,eAAO,MAAM,aAAa,qBAOzB,CAAC;AAEF,eAAO,MAAM,sBAAsB,qBAoHlC,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,wBAGnC;IACD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,mBA+DA,CAAC"}

package/dist/scripts/prepare-plugins-files.d.ts

@@ -1,2 +0,0 @@
-export declare const preparePluginsFiles: (flag?: string) => Promise<void>;
-//# sourceMappingURL=prepare-plugins-files.d.ts.map

package/dist/scripts/prepare-plugins-files.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prepare-plugins-files.d.ts","sourceRoot":"","sources":["../../scripts/prepare-plugins-files.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,mBAAmB,GAAU,OAAO,MAAM,kBAuTtD,CAAC"}

package/dist/scripts/run-interactive-shell-command.d.ts

@@ -1,2 +0,0 @@
-export declare const runInteractiveShellCommand: (cmd: string, args?: string[]) => Promise<unknown>;
-//# sourceMappingURL=run-interactive-shell-command.d.ts.map

package/dist/scripts/run-interactive-shell-command.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-interactive-shell-command.d.ts","sourceRoot":"","sources":["../../scripts/run-interactive-shell-command.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,0BAA0B,GACrC,KAAK,MAAM,EACX,OAAM,MAAM,EAAO,qBAqBpB,CAAC"}

package/dist/scripts/scripts.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=scripts.d.ts.map

package/dist/scripts/scripts.d.ts.map

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

package/dist/scripts/shared/file-utils.d.ts

@@ -1,15 +0,0 @@
-export declare const routeKey: (filePath: string, localeRoot: string) => string;
-export declare const buildInitialRouteMap: (localeRoot: string) => Map<string, string>;
-export declare const transformFileImports: (content: string, pluginName: string) => string;
-export declare function findRepoRoot(startPath: string): string;
-export declare function findLocaleRoot(repoRoot: string): string;
-export declare const getAllFiles: (dir: string) => string[];
-export declare const isDirectoryEmpty: (dir: string) => boolean;
-export interface SourceConfig {
-    destinationDir: string;
-    sourceDir: string;
-}
-export declare const copyFile: (srcPath: string, destPath: string, pluginName: string, routeMap: Map<string, string>, localeRoot: string, repoRoot: string, verbose?: boolean) => void;
-export declare const cleanupDeletedFiles: (sourceDir: string, destinationDir: string, removeFileFn: (p: string) => void) => void;
-export declare const copyDirectoryRecursive: (sourceDir: string, destinationDir: string, pluginName: string, routeMap: Map<string, string>, localeRoot: string, repoRoot: string, verbose?: boolean) => void;
-//# sourceMappingURL=file-utils.d.ts.map

package/dist/scripts/shared/file-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../../scripts/shared/file-utils.ts"],"names":[],"mappings":"AA6BA,eAAO,MAAM,QAAQ,GAAI,UAAU,MAAM,EAAE,YAAY,MAAM,KAAG,MAY/D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,KACjB,GAAG,CAAC,MAAM,EAAE,MAAM,CAwBpB,CAAC;AAGF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,YAAY,MAAM,KACjB,MA8DF,CAAC;AAEF,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAiBtD;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAkEvD;AAED,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,MAAM,EAgB/C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,KAAG,OAM9C,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,QAAQ,GACnB,SAAS,MAAM,EACf,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,YAAY,MAAM,EAClB,UAAU,MAAM,EAChB,iBAAc,SAoEf,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,cAAc,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,SAmBlC,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,WAAW,MAAM,EACjB,gBAAgB,MAAM,EACtB,YAAY,MAAM,EAClB,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,YAAY,MAAM,EAClB,UAAU,MAAM,EAChB,iBAAc,SAoBf,CAAC"}

package/dist/scripts/shared/file-utils.test.d.ts

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

package/dist/scripts/shared/file-utils.test.d.ts.map

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

package/dist/src/api/lib/cache.test.d.ts

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

package/dist/src/api/lib/cache.test.d.ts.map

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

package/dist/src/api/lib/cache.test.js

@@ -1 +0,0 @@
-import{describe,expect,it,vi}from"vitest";import{CacheModel}from"./cache.js";const fakeContext={get:()=>undefined};const LOCK_KEY="vitnode:cache:__system__:lock:queue:process";describe("CacheModel locks",()=>{describe("without Redis",()=>{const cache=new CacheModel(null,fakeContext);it("acquireLock returns true so cache-less deployments still proceed",async()=>{await expect(cache.acquireLock("queue:process",55)).resolves.toBe(true)});it("releaseLock is a no-op",async()=>{await expect(cache.releaseLock("queue:process")).resolves.toBeUndefined()})});describe("with Redis",()=>{it("acquires the lock with SET NX EX in the system namespace",async()=>{const set=vi.fn().mockResolvedValue("OK");const cache=new CacheModel({set},fakeContext);await expect(cache.acquireLock("queue:process",55)).resolves.toBe(true);expect(set).toHaveBeenCalledWith(LOCK_KEY,"1","EX",55,"NX")});it("returns false when the lock is already held",async()=>{const set=vi.fn().mockResolvedValue(null);const cache=new CacheModel({set},fakeContext);await expect(cache.acquireLock("queue:process",55)).resolves.toBe(false)});it("returns false when Redis errors, to skip rather than double-run",async()=>{const set=vi.fn().mockRejectedValue(new Error("down"));const cache=new CacheModel({set},fakeContext);await expect(cache.acquireLock("queue:process",55)).resolves.toBe(false)});it("releaseLock deletes the lock key",async()=>{const del=vi.fn().mockResolvedValue(1);const cache=new CacheModel({del},fakeContext);await cache.releaseLock("queue:process");expect(del).toHaveBeenCalledWith(LOCK_KEY)})})});

package/dist/src/api/models/email.test.d.ts

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

package/dist/src/api/models/email.test.d.ts.map

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

package/dist/src/api/models/email.test.js

@@ -1 +0,0 @@
-import{describe,expect,it,vi}from"vitest";vi.mock("react-email",()=>({render:vi.fn().mockResolvedValue("RENDERED")}));import{EmailModel}from"./email.js";const makeCtx=(overrides={})=>{const dispatch=vi.fn().mockResolvedValue({id:1});const sendEmail=vi.fn().mockResolvedValue(undefined);const error=vi.fn().mockResolvedValue(undefined);const store={core:{email:"email"in overrides?overrides.email:{adapter:{sendEmail}},plugins:[],metadata:{title:"Test"},pathToMessages:vi.fn().mockResolvedValue({default:{}})},queue:{dispatch},log:{error,warn:vi.fn(),debug:vi.fn()}};return{ctx:{get:k=>store[k]},dispatch,sendEmail,error}};describe("EmailModel.queue",()=>{it("renders the email and enqueues a send-email task",async()=>{const{ctx,dispatch}=makeCtx();await new EmailModel(ctx).send({to:"a@b.com",locale:"en",subject:"Hi",content:()=>null});expect(dispatch).toHaveBeenCalledWith({name:"send-email",payload:{to:"a@b.com",subject:"Hi",html:"RENDERED",text:"RENDERED"}})});it("resolves a function subject before enqueueing",async()=>{const{ctx,dispatch}=makeCtx();await new EmailModel(ctx).send({to:"a@b.com",locale:"en",subject:()=>"Computed",content:()=>null});expect(dispatch.mock.calls[0][0].payload.subject).toBe("Computed")});it("throws when no email provider is configured",async()=>{const{ctx,dispatch}=makeCtx({email:undefined});await expect(new EmailModel(ctx).send({to:"a@b.com",locale:"en",subject:"Hi",content:()=>null})).rejects.toThrow();expect(dispatch).not.toHaveBeenCalled()})});describe("EmailModel.deliver",()=>{it("sends a prebuilt email through the provider",async()=>{const{ctx,sendEmail}=makeCtx();await new EmailModel(ctx).deliver({to:"a@b.com",subject:"Hi",html:"<p>hi</p>",text:"hi"});expect(sendEmail).toHaveBeenCalledWith(expect.objectContaining({to:"a@b.com",subject:"Hi",html:"<p>hi</p>",text:"hi",metadata:{title:"Test"}}))})});

package/dist/src/api/models/queue.test.d.ts

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

package/dist/src/api/models/queue.test.d.ts.map

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

package/dist/src/api/models/queue.test.js

@@ -1 +0,0 @@
-import{describe,expect,it,vi}from"vitest";import{QueueModel}from"./queue.js";const makeCtx=(overrides={})=>{const values=vi.fn().mockReturnValue({returning:vi.fn().mockResolvedValue([{id:1}])});const store={db:{insert:vi.fn().mockReturnValue({values})},core:{queue:overrides.queue??[]},plugin:overrides.plugin};return{ctx:{get:k=>store[k]},values}};describe("QueueModel.dispatch",()=>{it("uses the explicit maxAttempts when provided",async()=>{const{ctx,values}=makeCtx({queue:[{name:"job",pluginId:"@vitnode/core",maxAttempts:5}]});await new QueueModel(ctx).dispatch({name:"job",maxAttempts:7});expect(values.mock.calls[0][0]).toMatchObject({maxAttempts:7})});it("falls back to the registered task maxAttempts",async()=>{const{ctx,values}=makeCtx({queue:[{name:"job",pluginId:"@vitnode/core",maxAttempts:5}]});await new QueueModel(ctx).dispatch({name:"job"});expect(values.mock.calls[0][0]).toMatchObject({maxAttempts:5})});it("defaults to 3 when the registered task has no maxAttempts",async()=>{const{ctx,values}=makeCtx({queue:[{name:"job",pluginId:"@vitnode/core"}]});await new QueueModel(ctx).dispatch({name:"job"});expect(values.mock.calls[0][0]).toMatchObject({maxAttempts:3})});it("defaults to 3 when the task is not registered",async()=>{const{ctx,values}=makeCtx({queue:[]});await new QueueModel(ctx).dispatch({name:"job"});expect(values.mock.calls[0][0]).toMatchObject({maxAttempts:3})});it("scopes the task lookup by pluginId",async()=>{const{ctx,values}=makeCtx({plugin:{id:"@vitnode/blog"},queue:[{name:"job",pluginId:"@vitnode/core",maxAttempts:5},{name:"job",pluginId:"@vitnode/blog",maxAttempts:9}]});await new QueueModel(ctx).dispatch({name:"job"});expect(values.mock.calls[0][0]).toMatchObject({pluginId:"@vitnode/blog",maxAttempts:9})})});

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/get-queue-backoff-date.test.d.ts

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

package/dist/src/lib/api/get-queue-backoff-date.test.d.ts.map

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

package/dist/src/lib/api/get-queue-backoff-date.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{getQueueBackoffDate}from"./get-queue-backoff-date.js";describe("getQueueBackoffDate",()=>{const from=new Date("2024-01-01T00:00:00Z");const secondsFrom=date=>(date.getTime()-from.getTime())/1e3;it("delays by the base amount after the first attempt",()=>{expect(secondsFrom(getQueueBackoffDate(1,from))).toBe(10)});it("grows exponentially with attempts",()=>{expect(secondsFrom(getQueueBackoffDate(2,from))).toBe(20);expect(secondsFrom(getQueueBackoffDate(3,from))).toBe(40);expect(secondsFrom(getQueueBackoffDate(4,from))).toBe(80)});it("is monotonically increasing",()=>{const delays=[1,2,3,4,5].map(a=>secondsFrom(getQueueBackoffDate(a,from)));for(let i=1;i<delays.length;i++){expect(delays[i]).toBeGreaterThan(delays[i-1])}});it("caps the delay at one hour",()=>{expect(secondsFrom(getQueueBackoffDate(50,from))).toBe(3600)});it("treats attempts <= 1 as the base delay (no negative exponent)",()=>{expect(secondsFrom(getQueueBackoffDate(0,from))).toBe(10)});it("returns a date after the provided origin",()=>{expect(getQueueBackoffDate(1,from).getTime()).toBeGreaterThan(from.getTime())})});

package/dist/src/lib/api/resolve-queue-task-outcome.test.d.ts

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

package/dist/src/lib/api/resolve-queue-task-outcome.test.d.ts.map

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

package/dist/src/lib/api/resolve-queue-task-outcome.test.js

@@ -1 +0,0 @@
-import{describe,expect,it}from"vitest";import{resolveQueueTaskOutcome}from"./resolve-queue-task-outcome.js";describe("resolveQueueTaskOutcome",()=>{const now=new Date("2024-01-01T00:00:00Z");it("completes when there is no error",()=>{const outcome=resolveQueueTaskOutcome({attempts:1,maxAttempts:3,now});expect(outcome.status).toBe("completed");expect(outcome.completedAt).toEqual(now);expect(outcome.lastError).toBeNull();expect(outcome.availableAt).toBeUndefined()});it("retries with a backoff when the error is recoverable",()=>{const outcome=resolveQueueTaskOutcome({attempts:1,maxAttempts:3,error:"boom",now});expect(outcome.status).toBe("pending");expect(outcome.lastError).toBe("boom");expect(outcome.availableAt?.getTime()).toBeGreaterThan(now.getTime());expect(outcome.completedAt).toBeUndefined()});it("fails once attempts reach maxAttempts",()=>{const outcome=resolveQueueTaskOutcome({attempts:3,maxAttempts:3,error:"boom",now});expect(outcome.status).toBe("failed");expect(outcome.lastError).toBe("boom");expect(outcome.completedAt).toEqual(now);expect(outcome.availableAt).toBeUndefined()});it("fails when attempts exceed maxAttempts",()=>{const outcome=resolveQueueTaskOutcome({attempts:5,maxAttempts:3,error:"boom",now});expect(outcome.status).toBe("failed")});it("backs off further on later retries",()=>{const first=resolveQueueTaskOutcome({attempts:1,maxAttempts:5,error:"boom",now});const second=resolveQueueTaskOutcome({attempts:2,maxAttempts:5,error:"boom",now});expect(second.availableAt?.getTime()).toBeGreaterThan(first.availableAt?.getTime()??0)})});

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":""}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/tests/setup.ts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,CAAC"}

package/dist/src/tests/setup.js

@@ -1 +0,0 @@
-import"@testing-library/react";