@calmlens/js-sdk 0.0.1 → 0.0.2

package/esm/User.js

@@ -0,0 +1,15 @@
+import * as zod from "zod/v4";
+import { metaStore, primaryKey } from "zodbase";
+import { ROLE_SCHEMA } from "./Roles";
+import { createdAtField, saneStringField, updatedAtField } from "./ZodUtils";
+export const USER_SCHEMA = zod.object({
+    id: zod.string().meta(metaStore([primaryKey()])),
+    createdAt: createdAtField(),
+    updatedAt: updatedAtField(),
+    email: saneStringField().nullish(),
+    firstName: saneStringField().nullish(),
+    lastName: saneStringField().nullish(),
+    customerId: saneStringField().nullish(),
+    roles: zod.array(ROLE_SCHEMA).nullish(),
+    freeUploadsUsed: zod.number().int().nonnegative().nullish(),
+});

package/esm/UtilTypes.d.ts

@@ -0,0 +1,30 @@
+import type React from "react";
+import type { HTMLProps } from "react";
+import type { User } from "./User";
+export type AppEnvironment = "local" | "dev" | "main";
+export type Breakpoint = "mobile" | "desktop";
+export type CommonHtmlProps = Omit<HTMLProps<HTMLDivElement>, "ref" | "as"> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
+export type Class<T> = new (...args: any[]) => T;
+export interface AuthState {
+    user: User;
+    subscription?: any | null;
+}
+export declare const FIT_TYPES: readonly ["contain", "cover", "fill"];
+export type Fit = (typeof FIT_TYPES)[number];
+export interface FieldSettings {
+    name: string;
+    disabled?: boolean;
+    value?: any;
+}
+export interface ImpersonationData {
+    originalUserId: string;
+    targetUser: {
+        id: string;
+        email: string | undefined | null;
+        firstName: string | undefined | null;
+        lastName: string | undefined | null;
+    };
+    startedAt: number;
+}

package/esm/UtilTypes.js

@@ -0,0 +1 @@
+export const FIT_TYPES = ["contain", "cover", "fill"];

package/esm/Workflow.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Workflow system for tracking asset processing pipelines
+ */
+import * as zod from "zod/v4";
+export type WorkflowStepStatus = "pending" | "in_progress" | "completed" | "skipped" | "error";
+export declare const WORKFLOW_STEP_STATUS_SCHEMA: zod.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    in_progress: "in_progress";
+    completed: "completed";
+    skipped: "skipped";
+}>;
+export declare const WORKFLOW_STEP_SCHEMA: zod.ZodObject<{
+    id: zod.ZodString;
+    label: zod.ZodString;
+    status: zod.ZodEnum<{
+        error: "error";
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        skipped: "skipped";
+    }>;
+    optional: zod.ZodOptional<zod.ZodBoolean>;
+    startedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    completedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    error: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+}, zod.z.core.$strip>;
+export declare const WORKFLOW_SCHEMA: zod.ZodObject<{
+    id: zod.ZodString;
+    name: zod.ZodString;
+    steps: zod.ZodArray<zod.ZodObject<{
+        id: zod.ZodString;
+        label: zod.ZodString;
+        status: zod.ZodEnum<{
+            error: "error";
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            skipped: "skipped";
+        }>;
+        optional: zod.ZodOptional<zod.ZodBoolean>;
+        startedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        completedAt: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+        error: zod.ZodOptional<zod.ZodNullable<zod.ZodString>>;
+    }, zod.z.core.$strip>>;
+    createdAt: zod.ZodString;
+    updatedAt: zod.ZodString;
+}, zod.z.core.$strip>;
+export type WorkflowStep = zod.infer<typeof WORKFLOW_STEP_SCHEMA>;
+export type Workflow = zod.infer<typeof WORKFLOW_SCHEMA>;
+/**
+ * Create a new workflow
+ */
+export declare function createWorkflow(id: string, name: string, stepDefinitions: Array<{
+    id: string;
+    label: string;
+    optional?: boolean;
+}>): Workflow;

package/esm/Workflow.js

@@ -0,0 +1,46 @@
+/**
+ * Workflow system for tracking asset processing pipelines
+ */
+import * as zod from "zod/v4";
+export const WORKFLOW_STEP_STATUS_SCHEMA = zod.enum([
+    "pending",
+    "in_progress",
+    "completed",
+    "skipped",
+    "error",
+]);
+export const WORKFLOW_STEP_SCHEMA = zod.object({
+    id: zod.string(),
+    label: zod.string(),
+    status: WORKFLOW_STEP_STATUS_SCHEMA,
+    optional: zod.boolean().optional(),
+    startedAt: zod.string().nullish(),
+    completedAt: zod.string().nullish(),
+    error: zod.string().nullish(),
+});
+export const WORKFLOW_SCHEMA = zod.object({
+    id: zod.string(),
+    name: zod.string(),
+    steps: zod.array(WORKFLOW_STEP_SCHEMA),
+    createdAt: zod.string(),
+    updatedAt: zod.string(),
+});
+/**
+ * Create a new workflow
+ */
+export function createWorkflow(id, name, stepDefinitions) {
+    const now = new Date().toISOString();
+    return {
+        id,
+        name,
+        steps: stepDefinitions.map((def, index) => ({
+            id: def.id,
+            label: def.label,
+            status: index === 0 ? "in_progress" : "pending",
+            optional: def.optional,
+            startedAt: index === 0 ? now : undefined,
+        })),
+        createdAt: now,
+        updatedAt: now,
+    };
+}

package/esm/ZodUtils.d.ts

@@ -0,0 +1,39 @@
+import * as zod from "zod/v4";
+import type { Class } from "./UtilTypes";
+export declare const isZodRequired: (type: zod.ZodType) => boolean;
+export interface SchemaDisplayInfo {
+    type?: string;
+    mainType: string;
+    optional?: boolean;
+    description?: string;
+    defaultValue?: string | number | boolean;
+    placeholder?: string;
+    enumValues?: string[];
+    namedType?: string;
+}
+export declare const getZodTypeChain: (type: zod.ZodType) => zod.ZodType[];
+export declare const getSchemaDisplayInfo: (type: zod.ZodType) => SchemaDisplayInfo;
+export declare const isZodTypeExtends: (type: zod.ZodType, zodType: Class<zod.ZodType>) => zod.ZodType | false;
+export type NonNullableObject<T> = {
+    [K in keyof T]: NonNullable<T[K]>;
+};
+export declare const nonNullable: <T extends zod.ZodRawShape>(schema: zod.ZodObject<T>) => zod.ZodObject<NonNullableObject<T>>;
+export interface SaneStringOptions {
+    type?: "small" | "medium" | "large";
+    minWidth?: number;
+}
+export declare const primaryUuidField: () => zod.ZodString;
+export declare const uuidField: () => zod.ZodString;
+export declare const createdAtField: () => zod.ZodNumber;
+export declare const updatedAtField: () => zod.ZodOptional<zod.ZodNumber>;
+export interface SaneStringOptions {
+    type?: "small" | "medium" | "large";
+    minWidth?: number;
+}
+export declare const saneStringField: (options?: SaneStringOptions) => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+export declare const urlField: () => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+export declare const rsqlField: () => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+/**
+ * Converts a Zod schema to a TypeScript type definition string
+ */
+export declare const zodSchemaToTypeScript: (schema: zod.ZodType, indent?: number) => string;

package/esm/ZodUtils.js

@@ -0,0 +1,266 @@
+import * as zod from "zod/v4";
+import { getMetaItem } from "zod-meta";
+import { metaStore, primaryKey, updatedAt } from "zodbase";
+import { docPropertyInfo } from "./DocMetaTypes";
+import { validateUrl } from "./ValidationUtils";
+export const isZodRequired = (type) => {
+    return !isZodTypeExtends(type, zod.ZodOptional);
+};
+export const getZodTypeChain = (type) => {
+    var _a;
+    const chain = [];
+    let current = type;
+    while (current === null || current === void 0 ? void 0 : current.def) {
+        chain.push(current);
+        const innerType = (_a = current.def.innerType) !== null && _a !== void 0 ? _a : current.def.in;
+        current = innerType === current ? null : innerType;
+    }
+    return chain;
+};
+export const getSchemaDisplayInfo = (type) => {
+    const chain = getZodTypeChain(type);
+    const metaItem = getMetaItem(type, docPropertyInfo);
+    const description = (metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.description) || type.description;
+    const defaultValue = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.defaultValue;
+    const placeholder = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.placeholder;
+    const namedType = metaItem === null || metaItem === void 0 ? void 0 : metaItem.data.namedType;
+    let mainType = type;
+    const qualifierTypes = new Set();
+    let enumValues;
+    for (const item of chain) {
+        if (item.def.innerType) {
+            if (item.def.type === "nullable" || item.def.type === "optional") {
+                qualifierTypes.add("optional");
+            }
+        }
+        else {
+            mainType = item;
+        }
+        // Check for enum values
+        if (item.def.type === "enum") {
+            // @ts-expect-error
+            enumValues = Object.values(item.def.entries);
+        }
+    }
+    let typeDisplay = mainType.def.type;
+    // If it's an enum, show the enum values
+    if (enumValues && enumValues.length > 0) {
+        typeDisplay = "enum";
+    }
+    return {
+        mainType: mainType.def.type,
+        description,
+        defaultValue,
+        placeholder,
+        optional: !isZodRequired(type),
+        enumValues,
+        namedType,
+        type: `${typeDisplay}${qualifierTypes.size > 0 ? ` (${Array.from(qualifierTypes).join(", ")})` : ""}`,
+    };
+};
+export const isZodTypeExtends = (type, zodType) => {
+    if (type instanceof zodType) {
+        return type;
+    }
+    // @ts-expect-error
+    if (type.def.type === "union") {
+        // @ts-expect-error
+        for (const option of type.def.options) {
+            if (isZodTypeExtends(option, zodType)) {
+                return option;
+            }
+        }
+        return false;
+    }
+    // @ts-expect-error
+    const rootType = type.def.innerType;
+    if (rootType) {
+        return isZodTypeExtends(rootType, zodType);
+    }
+    return false;
+};
+export const nonNullable = (schema) => {
+    return schema.refine((data) => {
+        if (data === null || data === undefined) {
+            return false;
+        }
+        for (const key in data) {
+            if (data[key] === null || data[key] === undefined) {
+                return false;
+            }
+        }
+        return true;
+    }, {
+        message: "Value cannot contain null or undefined",
+    });
+};
+export const primaryUuidField = () => zod
+    .string()
+    .uuid({
+    version: "v4",
+})
+    .meta(metaStore([primaryKey()]));
+export const uuidField = () => zod.string().uuid({
+    version: "v4",
+});
+export const createdAtField = () => zod.number().int();
+export const updatedAtField = () => zod
+    .number()
+    .int()
+    .optional()
+    .meta(metaStore([updatedAt()]));
+const SIZE_LIMITS = {
+    small: 64,
+    medium: 200,
+    large: 1500,
+};
+export const saneStringField = (options) => {
+    return zod
+        .string()
+        .transform((value) => value.trim())
+        .refine((value) => {
+        if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) {
+            return false;
+        }
+        return true;
+    }, "Not long enough")
+        .refine((value) => {
+        var _a;
+        const sizeLimit = SIZE_LIMITS[(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : "medium"];
+        return typeof value === "string" && value.length < sizeLimit;
+    }, "Too long");
+};
+export const urlField = () => saneStringField().refine((value) => {
+    /*if (encodeURI(value) !== value) {
+      return false;
+    }*/
+    const parsedUrl = validateUrl(value);
+    return Boolean(parsedUrl);
+}, "Invalid link");
+export const rsqlField = () => {
+    return saneStringField({
+        type: "large",
+    }).meta(metaStore([
+        docPropertyInfo({
+            description: "RSQL filter string for filtering results. See [REST API Documentation](/docs/rest) for detailed syntax.\n\n**Examples:**\n- `status==rejected;parentId==null` (AND conditions)\n- `status==rejected,status==error` (OR conditions)\n- `price>100;price<500` (range filtering)\n- `tags=in=(react,typescript)` (array membership)\n\n**Supported operators:** `==`, `!=`, `>`, `>=`, `<`, `<=`, `=in=`, `=out=`, `=like=`\n\n**Logical operators:** `;` (AND), `,` (OR)",
+            placeholder: "status==approved;type==image",
+        }),
+    ]));
+};
+/**
+ * Converts a Zod schema to a TypeScript type definition string
+ */
+export const zodSchemaToTypeScript = (schema, indent = 0) => {
+    const spaces = "  ".repeat(indent);
+    const chain = getZodTypeChain(schema);
+    // Check for optional/nullable
+    const isOptional = chain.some((s) => s.def.type === "optional");
+    const isNullable = chain.some((s) => s.def.type === "nullable");
+    // Get the core type
+    let coreSchema = schema;
+    for (const s of chain) {
+        if (s.def.innerType) {
+            coreSchema = s.def.innerType;
+        }
+    }
+    let typeStr = "";
+    // Handle different types
+    if (coreSchema.def.type === "string") {
+        typeStr = "string";
+    }
+    else if (coreSchema.def.type === "number") {
+        typeStr = "number";
+    }
+    else if (coreSchema.def.type === "boolean") {
+        typeStr = "boolean";
+    }
+    else if (coreSchema.def.type === "bigint") {
+        typeStr = "bigint";
+    }
+    else if (coreSchema.def.type === "date") {
+        typeStr = "Date";
+    }
+    else if (coreSchema.def.type === "null") {
+        typeStr = "null";
+    }
+    else if (coreSchema.def.type === "undefined") {
+        typeStr = "undefined";
+    }
+    else if (coreSchema.def.type === "any") {
+        typeStr = "any";
+    }
+    else if (coreSchema.def.type === "unknown") {
+        typeStr = "unknown";
+    }
+    else if (coreSchema.def.type === "never") {
+        typeStr = "never";
+    }
+    else if (coreSchema.def.type === "void") {
+        typeStr = "void";
+    }
+    else if (coreSchema.def.type === "literal") {
+        const value = coreSchema.def.value;
+        typeStr = typeof value === "string" ? `"${value}"` : String(value);
+    }
+    else if (coreSchema.def.type === "enum") {
+        const entries = Object.values(coreSchema.def.entries);
+        typeStr = entries.map((e) => `"${e}"`).join(" | ");
+    }
+    else if (coreSchema.def.type === "array") {
+        const element = coreSchema.def.element;
+        const elementType = zodSchemaToTypeScript(element, indent);
+        typeStr = `${elementType}[]`;
+    }
+    else if (coreSchema.def.type === "object") {
+        const shape = coreSchema.def.shape || {};
+        const fields = Object.entries(shape).map(([key, fieldSchema]) => {
+            const fieldInfo = getSchemaDisplayInfo(fieldSchema);
+            const fieldType = zodSchemaToTypeScript(fieldSchema, indent + 1);
+            const optional = fieldInfo.optional ? "?" : "";
+            return `${spaces}  ${key}${optional}: ${fieldType};`;
+        });
+        if (fields.length === 0) {
+            typeStr = "{}";
+        }
+        else {
+            typeStr = `{\n${fields.join("\n")}\n${spaces}}`;
+        }
+    }
+    else if (coreSchema.def.type === "union") {
+        const options = coreSchema.def.options || [];
+        const types = options.map((opt) => zodSchemaToTypeScript(opt, indent));
+        typeStr = types.join(" | ");
+    }
+    else if (coreSchema.def.type === "intersection") {
+        const left = coreSchema.def.left;
+        const right = coreSchema.def.right;
+        const leftType = zodSchemaToTypeScript(left, indent);
+        const rightType = zodSchemaToTypeScript(right, indent);
+        typeStr = `${leftType} & ${rightType}`;
+    }
+    else if (coreSchema.def.type === "record") {
+        const keyType = coreSchema.def.keyType
+            ? zodSchemaToTypeScript(coreSchema.def.keyType, indent)
+            : "string";
+        const valueType = coreSchema.def.valueType
+            ? zodSchemaToTypeScript(coreSchema.def.valueType, indent)
+            : "any";
+        typeStr = `Record<${keyType}, ${valueType}>`;
+    }
+    else if (coreSchema.def.type === "tuple") {
+        const items = coreSchema.def.items || [];
+        const types = items.map((item) => zodSchemaToTypeScript(item, indent));
+        typeStr = `[${types.join(", ")}]`;
+    }
+    else {
+        typeStr = "unknown";
+    }
+    // Add optional/nullable modifiers
+    if (isNullable && !typeStr.includes("null")) {
+        typeStr = `${typeStr} | null`;
+    }
+    if (isOptional && indent === 0) {
+        typeStr = `${typeStr} | undefined`;
+    }
+    return typeStr;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calmlens/js-sdk",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "cjs/index.js",
   "types": "esm/index.d.ts",
   "module": "esm/index.js",
@@ -15,7 +15,7 @@
     "cleanup": "rimraf esm && rimraf cjs",
     "build": "npm run cleanup && npm run build:esm && npm run build:cjs",
     "build:esm": "tsc --module es2015 --target es2016 --outDir esm --preserveWatchOutput && rm -rf esm/tests && node scripts/post-build.js esm",
-    "build:cjs": "tsc --module commonjs --target es5 --outDir cjs --preserveWatchOutput && rm -rf cjs/tests && node scripts/post-build.js cjs",
+    "build:cjs": "tsc --module commonjs --moduleResolution node --target es5 --outDir cjs --preserveWatchOutput && rm -rf cjs/tests && node scripts/post-build.js cjs",
     "website:dev": "cd website && npm run start",
     "website:deploy": "cd website && npm run deploy"
   },
@@ -49,23 +49,23 @@
     }
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.5",
-    "@swc/core": "^1.13.5",
+    "@biomejs/biome": "^2.3.11",
+    "@swc/core": "^1.15.8",
     "@swc/jest": "^0.2.39",
-    "@types/bun": "^1.2.22",
+    "@types/bun": "^1.3.6",
     "@types/jest": "^30.0.0",
-    "@types/lodash": "^4.17.20",
-    "@types/node": "24.6.2",
+    "@types/lodash": "^4.17.23",
+    "@types/node": "25.0.9",
     "chalk": "4.1.2",
     "cross-env": "10.1.0",
-    "esbuild": "^0.25.10",
+    "esbuild": "^0.27.2",
     "jest": "30.2.0",
     "npm-run-all": "4.1.5",
-    "rimraf": "6.0.1",
+    "rimraf": "6.1.2",
     "typescript": "^5.9.3",
     "zod": "4.1.3"
   },
   "dependencies": {
-    "api-def": "^0.12.0-alpha.55"
+    "api-def": "^0.12.0"
   }
 }

package/cjs/SchemaUtils.d.ts

@@ -1,11 +0,0 @@
-import * as zod from "zod/v4";
-export declare const primaryUuidField: () => zod.ZodString;
-export declare const uuidField: () => zod.ZodString;
-export declare const createdAtField: () => zod.ZodNumber;
-export declare const updatedAtField: () => zod.ZodOptional<zod.ZodNumber>;
-export interface SaneStringOptions {
-    type?: "small" | "medium" | "large";
-    minWidth?: number;
-}
-export declare const saneStringField: (options?: SaneStringOptions) => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
-export declare const urlField: () => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;

package/cjs/SchemaUtils.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.urlField = exports.saneStringField = exports.updatedAtField = exports.createdAtField = exports.uuidField = exports.primaryUuidField = void 0;
-var zod = require("zod/v4");
-var zodbase_1 = require("zodbase");
-var ValidationUtils_1 = require("./ValidationUtils");
-var primaryUuidField = function () {
-    return zod
-        .string()
-        .uuid({
-        version: "v4",
-    })
-        .meta((0, zodbase_1.meta)([(0, zodbase_1.primaryKey)()]));
-};
-exports.primaryUuidField = primaryUuidField;
-var uuidField = function () {
-    return zod.string().uuid({
-        version: "v4",
-    });
-};
-exports.uuidField = uuidField;
-var createdAtField = function () { return zod.number().int(); };
-exports.createdAtField = createdAtField;
-var updatedAtField = function () {
-    return zod
-        .number()
-        .int()
-        .optional()
-        .meta((0, zodbase_1.meta)([(0, zodbase_1.updatedAt)()]));
-};
-exports.updatedAtField = updatedAtField;
-var SIZE_LIMITS = {
-    small: 64,
-    medium: 200,
-    large: 1500,
-};
-var saneStringField = function (options) {
-    return zod
-        .string()
-        .transform(function (value) { return value.trim(); })
-        .refine(function (value) {
-        if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) {
-            return false;
-        }
-        return true;
-    }, "Not long enough")
-        .refine(function (value) {
-        var _a;
-        var sizeLimit = SIZE_LIMITS[(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : "medium"];
-        return typeof value === "string" && value.length < sizeLimit;
-    }, "Too long");
-};
-exports.saneStringField = saneStringField;
-var urlField = function () {
-    return (0, exports.saneStringField)().refine(function (value) {
-        /*if (encodeURI(value) !== value) {
-          return false;
-        }*/
-        var parsedUrl = (0, ValidationUtils_1.validateUrl)(value);
-        return Boolean(parsedUrl);
-    }, "Invalid link");
-};
-exports.urlField = urlField;

package/esm/SchemaUtils.d.ts

@@ -1,11 +0,0 @@
-import * as zod from "zod/v4";
-export declare const primaryUuidField: () => zod.ZodString;
-export declare const uuidField: () => zod.ZodString;
-export declare const createdAtField: () => zod.ZodNumber;
-export declare const updatedAtField: () => zod.ZodOptional<zod.ZodNumber>;
-export interface SaneStringOptions {
-    type?: "small" | "medium" | "large";
-    minWidth?: number;
-}
-export declare const saneStringField: (options?: SaneStringOptions) => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
-export declare const urlField: () => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;

package/esm/SchemaUtils.js

@@ -1,46 +0,0 @@
-import * as zod from "zod/v4";
-import { meta, primaryKey, updatedAt } from "zodbase";
-import { validateUrl } from "./ValidationUtils";
-export const primaryUuidField = () => zod
-    .string()
-    .uuid({
-    version: "v4",
-})
-    .meta(meta([primaryKey()]));
-export const uuidField = () => zod.string().uuid({
-    version: "v4",
-});
-export const createdAtField = () => zod.number().int();
-export const updatedAtField = () => zod
-    .number()
-    .int()
-    .optional()
-    .meta(meta([updatedAt()]));
-const SIZE_LIMITS = {
-    small: 64,
-    medium: 200,
-    large: 1500,
-};
-export const saneStringField = (options) => {
-    return zod
-        .string()
-        .transform((value) => value.trim())
-        .refine((value) => {
-        if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) {
-            return false;
-        }
-        return true;
-    }, "Not long enough")
-        .refine((value) => {
-        var _a;
-        const sizeLimit = SIZE_LIMITS[(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : "medium"];
-        return typeof value === "string" && value.length < sizeLimit;
-    }, "Too long");
-};
-export const urlField = () => saneStringField().refine((value) => {
-    /*if (encodeURI(value) !== value) {
-      return false;
-    }*/
-    const parsedUrl = validateUrl(value);
-    return Boolean(parsedUrl);
-}, "Invalid link");