@ciwergrp/nuxid 1.5.2 → 1.5.4

package/README.md

@@ -160,6 +160,35 @@ export default defineNuxtConfig({
 
 Disable any feature by setting it to `false` (e.g. `nuxid: { lodash: false }`).
 
+## Structure Directory
+
+This module is designed to work best in a Nuxt + pnpm monorepo, where each product or domain is its own Nuxt app under `apps/`, and shared building blocks live in `layers/` as Nuxt layers. The root of the repo acts as the single workspace: dependency versions, lint config, TypeScript config, and tooling live at the top level, while apps and layers are composed via Nuxt’s layer system. This keeps per-domain apps small and focused, encourages reuse without copy/paste, and makes it easy to scale multiple teams or products inside one repo.
+
+Recommended top-level structure:
+
+```bash
+% ls -l
+total 1008
+-rw-r--r--@   1 bagusvnt  staff   14838 Jan 12 13:24 AGENTS.md
+-rw-r--r--    1 bagusvnt  staff     371 Jan  7 10:45 README.md
+drwxr-xr-x    5 bagusvnt  staff     160 Jan  7 11:46 apps
+-rw-r--r--@   1 bagusvnt  staff     134 Jan  7 12:26 docker-compose.yml
+-rw-r--r--    1 bagusvnt  staff    1103 Jan  7 10:45 eslint.config.mjs
+drwxr-xr-x    4 bagusvnt  staff     128 Jan  7 10:45 layers
+drwxr-xr-x@ 781 bagusvnt  staff   24992 Jan 15 10:06 node_modules
+-rw-r--r--@   1 bagusvnt  staff    1158 Jan 15 10:06 package.json
+-rw-r--r--@   1 bagusvnt  staff  474254 Jan 15 10:06 pnpm-lock.yaml
+-rw-r--r--    1 bagusvnt  staff      38 Jan  7 10:45 pnpm-workspace.yaml
+-rw-r--r--    1 bagusvnt  staff     566 Jan  7 10:45 tsconfig.json
+```
+
+Inside `apps/`, each app represents a domain or product boundary (for example `apps/admin/`) and owns its `nuxt.config.ts`, routing, and app-specific modules. Inside `layers/`, you keep shared pieces such as UI components, composables, config, and utilities that can be layered into any app. Each layer is also a Nuxt project with its own `nuxt.config.ts`, so you can expose components, auto-imports, and module options from that layer while keeping a clean separation of concerns.
+
+Examples:
+
+- `apps/admin/nuxt.config.ts`
+- `layers/ui/nuxt.config.ts`
+
 ## Development
 
 ```bash

package/console/request.mjs

@@ -18,6 +18,21 @@ const availableRules = [
   'string',
   'nullable',
   'email',
+  'accepted',
+  'accepted_if',
+  'boolean',
+  'filled',
+  'present',
+  'required_if',
+  'required_unless',
+  'required_with',
+  'required_with_all',
+  'required_without',
+  'required_without_all',
+  'prohibited',
+  'prohibited_if',
+  'prohibited_unless',
+  'prohibits',
   'alpha',
   'alpha_num',
   'alpha_dash',
@@ -25,16 +40,33 @@ const availableRules = [
   'alpha_space',
   'numeric',
   'integer',
+  'confirmed',
+  'digits',
+  'digits_between',
   'bail',
+  'date_format',
   'date',
   'before',
   'after',
+  'before_or_equal',
+  'after_or_equal',
   'array',
+  'distinct',
+  'in_array',
+  'required_array_keys',
+  'list',
   'url',
   'ip',
   'hex_color',
+  'lowercase',
+  'uppercase',
+  'uuid',
+  'ulid',
+  'timezone',
   'min',
   'max',
+  'between',
+  'size',
   'same',
   'different',
   'gt',
@@ -42,26 +74,50 @@ const availableRules = [
   'lt',
   'lte',
   'in',
+  'multiple_of',
+  'decimal',
   'starts_with',
   'ends_with',
   'regex',
 ];
 
 const parameterizedRules = new Set([
+  'accepted_if',
+  'required_if',
+  'required_unless',
+  'required_with',
+  'required_with_all',
+  'required_without',
+  'required_without_all',
+  'prohibited_if',
+  'prohibited_unless',
+  'prohibits',
   'min',
   'max',
+  'between',
+  'size',
   'same',
   'different',
   'gt',
   'gte',
   'lt',
   'lte',
+  'digits',
+  'digits_between',
   'starts_with',
   'ends_with',
   'regex',
   'before',
   'after',
+  'before_or_equal',
+  'after_or_equal',
+  'date_format',
   'in',
+  'in_array',
+  'required_array_keys',
+  'multiple_of',
+  'decimal',
+  'timezone',
 ]);
 
 function toCamelCase(str) {

package/dist/module.d.mts

@@ -11,6 +11,11 @@ interface LodashOptions {
      * @default true
      */
     enabled: boolean;
+    /**
+     * Auto-import mode
+     * @default 'factory'
+     */
+    mode: 'factory' | 'prefix';
     /**
      * Prefix applied to each import (set `false` to disable)
      * @default 'use'

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@ciwergrp/nuxid",
   "configKey": "nuxid",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -34,6 +34,7 @@ const lodashExcludes = [
 
 const lodashDefaults = {
   enabled: false,
+  mode: "factory",
   // prefix: false,
   prefix: "ki",
   prefixSkip: "is",
@@ -63,6 +64,10 @@ function registerLodashFeature(options, resolve) {
   if (!options.enabled) {
     return;
   }
+  if (options.mode === "factory") {
+    addImports({ name: "lodash", from: resolve("./runtime/lodash-factory") });
+    return;
+  }
   const aliasMap = new Map(options.alias);
   const excludes = new Set(options.exclude);
   const skipPrefixes = toArray(options.prefixSkip);

package/dist/runtime/lodash-factory.d.ts

@@ -0,0 +1,2 @@
+import * as lodashLib from 'lodash-es';
+export declare function lodash(): typeof lodashLib;

package/dist/runtime/lodash-factory.js

@@ -0,0 +1,4 @@
+import * as lodashLib from "lodash-es";
+export function lodash() {
+  return lodashLib;
+}

package/dist/runtime/validator.d.ts

@@ -1,5 +1,5 @@
 import type { FormRules } from 'element-plus';
-export type ValidationRule = 'required' | 'string' | 'nullable' | 'email' | `min:${number}` | `max:${number}` | `same:${string}` | 'alpha' | 'alpha_num' | 'alpha_dash' | 'alphanumeric_space' | 'alpha_space' | 'numeric' | 'integer' | 'bail' | `different:${string}` | `gt:${string}` | `gte:${string}` | `lt:${string}` | `lte:${string}` | `starts_with:${string}` | `ends_with:${string}` | `regex:${string}` | 'date' | `before:${string}` | `after:${string}` | 'array' | 'url' | 'ip' | 'hex_color' | `in:${string}`;
+export type ValidationRule = 'required' | 'string' | 'nullable' | 'email' | 'accepted' | `accepted_if:${string}` | 'boolean' | 'filled' | 'present' | `required_if:${string}` | `required_unless:${string}` | `required_with:${string}` | `required_with_all:${string}` | `required_without:${string}` | `required_without_all:${string}` | 'prohibited' | `prohibited_if:${string}` | `prohibited_unless:${string}` | `prohibits:${string}` | `min:${number}` | `max:${number}` | `between:${number},${number}` | `size:${number}` | `same:${string}` | 'alpha' | 'alpha_num' | 'alpha_dash' | 'alphanumeric_space' | 'alpha_space' | 'numeric' | 'integer' | 'confirmed' | `digits:${number}` | `digits_between:${number},${number}` | 'bail' | `different:${string}` | `gt:${string}` | `gte:${string}` | `lt:${string}` | `lte:${string}` | `starts_with:${string}` | `ends_with:${string}` | `regex:${string}` | `date_format:${string}` | 'date' | `before:${string}` | `after:${string}` | `before_or_equal:${string}` | `after_or_equal:${string}` | 'array' | 'distinct' | `in_array:${string}` | `required_array_keys:${string}` | 'list' | 'url' | 'ip' | 'hex_color' | `in:${string}` | `multiple_of:${number}` | `decimal:${number}` | `decimal:${number},${number}` | 'lowercase' | 'uppercase' | 'uuid' | 'ulid' | `timezone:${string}` | 'timezone';
 export interface ValidationOptions {
     messages?: Record<string, string>;
     attributes?: Record<string, string>;

package/dist/runtime/validator.js

@@ -1,8 +1,5 @@
 const createSameAsValidator = (otherField, formState, message) => {
   return (_rule, value, callback) => {
-    const getNestedValue = (obj, path) => {
-      return path.split(".").reduce((current, key) => current?.[key], obj);
-    };
     const otherValue = getNestedValue(formState, otherField);
     if (value !== otherValue) {
       callback(new Error(message));
@@ -11,6 +8,117 @@ const createSameAsValidator = (otherField, formState, message) => {
     }
   };
 };
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((current, key) => current?.[key], obj);
+};
+const isEmptyValue = (value) => value === null || value === void 0 || value === "";
+const isFilledValue = (value) => {
+  if (isEmptyValue(value)) {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.length > 0;
+  }
+  if (typeof value === "object") {
+    return Object.keys(value).length > 0;
+  }
+  return true;
+};
+const hasNestedKey = (obj, path) => {
+  return path.split(".").every((key) => {
+    if (obj === null || obj === void 0) {
+      return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      obj = obj[key];
+      return true;
+    }
+    return false;
+  });
+};
+const normalizeComparisonValue = (value, expected) => {
+  if (expected === "null") {
+    return value === null || value === void 0;
+  }
+  if (expected === "true") {
+    return value === true || value === "true" || value === 1 || value === "1";
+  }
+  if (expected === "false") {
+    return value === false || value === "false" || value === 0 || value === "0";
+  }
+  return String(value) === expected;
+};
+const hasAnyFilled = (formState, fields) => {
+  return fields.some((field) => isFilledValue(getNestedValue(formState, field)));
+};
+const hasAllFilled = (formState, fields) => {
+  return fields.every((field) => isFilledValue(getNestedValue(formState, field)));
+};
+const getConfirmationField = (fieldName) => {
+  const segments = fieldName.split(".");
+  const last = segments.pop() || fieldName;
+  segments.push(`${last}_confirmation`);
+  return segments.join(".");
+};
+const getSizeValue = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (Array.isArray(value)) {
+    return value.length;
+  }
+  if (value && typeof value === "object") {
+    return Object.keys(value).length;
+  }
+  return null;
+};
+const isAcceptedValue = (value) => {
+  if (typeof value === "string") {
+    return ["yes", "on", "1", "true"].includes(value.toLowerCase());
+  }
+  return value === true || value === 1;
+};
+const isBooleanValue = (value) => {
+  return value === true || value === false || value === 0 || value === 1 || value === "0" || value === "1";
+};
+const createDateFormatValidator = (format, message) => {
+  const tokenMap = {
+    Y: "\\d{4}",
+    m: "(0[1-9]|1[0-2])",
+    d: "(0[1-9]|[12]\\d|3[01])",
+    H: "([01]\\d|2[0-3])",
+    i: "([0-5]\\d)",
+    s: "([0-5]\\d)"
+  };
+  let pattern = "^";
+  for (let i = 0; i < format.length; i += 1) {
+    const char = format[i];
+    if (char === "\\" && i + 1 < format.length) {
+      pattern += format[i + 1].replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+      i += 1;
+      continue;
+    }
+    if (tokenMap[char]) {
+      pattern += tokenMap[char];
+    } else {
+      pattern += char.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
+    }
+  }
+  pattern += "$";
+  const regex = new RegExp(pattern);
+  return (_rule, value, callback) => {
+    if (isEmptyValue(value)) {
+      return callback();
+    }
+    if (typeof value !== "string" || !regex.test(value)) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
 const createPatternValidator = (pattern, message) => {
   return (_rule, value, callback) => {
     if (value && !pattern.test(value)) {
@@ -186,6 +294,16 @@ export const createValidationRules = (definitions, formState, options = {}) => {
     } else {
       laravelRules = fieldDefinition;
     }
+    const hasNullable = laravelRules.includes("nullable");
+    const hasRequired = laravelRules.includes("required");
+    if (hasNullable && hasRequired) {
+      throw new Error(`Invalid validation rules for "${fieldName}": "nullable" cannot be combined with "required".`);
+    }
+    const fieldValue = getNestedValue(dataToValidate, fieldName);
+    if (hasNullable && !hasRequired && isEmptyValue(fieldValue)) {
+      rules[fieldName] = [];
+      continue;
+    }
     const fieldRules = [];
     const attributeName = attributes[fieldName] || fieldName;
     laravelRules.forEach((ruleString) => {
@@ -200,6 +318,289 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             trigger: pickTrigger(fieldName, "blur")
           });
           break;
+        case "accepted":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isAcceptedValue(value)) {
+                return callback();
+              }
+              callback(new Error(getMessage(fieldName, "accepted", `${attributeName} must be accepted`)));
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        case "accepted_if": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherField = firstParam;
+          const expectedValues = paramValues.slice(1);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              const otherValue = getNestedValue(dataToValidate, otherField);
+              const shouldRequire = expectedValues.some((expected) => normalizeComparisonValue(otherValue, expected));
+              if (!shouldRequire) {
+                return callback();
+              }
+              if (!isAcceptedValue(value)) {
+                return callback(new Error(getMessage(fieldName, "accepted_if", `${attributeName} must be accepted`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        }
+        case "boolean":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (!isBooleanValue(value)) {
+                return callback(new Error(getMessage(fieldName, "boolean", `${attributeName} must be true or false`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        case "filled":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (!hasNestedKey(dataToValidate, fieldName)) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "filled", `${attributeName} must not be empty`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "present":
+          fieldRules.push({
+            validator: (_rule, _value, callback) => {
+              if (!hasNestedKey(dataToValidate, fieldName)) {
+                return callback(new Error(getMessage(fieldName, "present", `${attributeName} must be present`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "required_if": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherField = firstParam;
+          const expectedValues = paramValues.slice(1);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              const otherValue = getNestedValue(dataToValidate, otherField);
+              const shouldRequire = expectedValues.some((expected) => normalizeComparisonValue(otherValue, expected));
+              if (!shouldRequire) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_if", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "required_unless": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherField = firstParam;
+          const expectedValues = paramValues.slice(1);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              const otherValue = getNestedValue(dataToValidate, otherField);
+              const isExcluded = expectedValues.some((expected) => normalizeComparisonValue(otherValue, expected));
+              if (isExcluded) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_unless", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "required_with": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherFields = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (!hasAnyFilled(dataToValidate, otherFields)) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_with", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "required_with_all": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherFields = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (!hasAllFilled(dataToValidate, otherFields)) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_with_all", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "required_without": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherFields = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (hasAnyFilled(dataToValidate, otherFields)) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_without", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "required_without_all": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherFields = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (hasAllFilled(dataToValidate, otherFields)) {
+                return callback();
+              }
+              if (!isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_without_all", `${attributeName} is required`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "prohibited":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "prohibited", `${attributeName} must be empty`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "prohibited_if": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherField = firstParam;
+          const expectedValues = paramValues.slice(1);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              const otherValue = getNestedValue(dataToValidate, otherField);
+              const shouldProhibit = expectedValues.some((expected) => normalizeComparisonValue(otherValue, expected));
+              if (!shouldProhibit) {
+                return callback();
+              }
+              if (isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "prohibited_if", `${attributeName} must be empty`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "prohibited_unless": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherField = firstParam;
+          const expectedValues = paramValues.slice(1);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              const otherValue = getNestedValue(dataToValidate, otherField);
+              const isAllowed = expectedValues.some((expected) => normalizeComparisonValue(otherValue, expected));
+              if (isAllowed) {
+                return callback();
+              }
+              if (isFilledValue(value)) {
+                return callback(new Error(getMessage(fieldName, "prohibited_unless", `${attributeName} must be empty`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "prohibits": {
+          if (!paramValues.length) {
+            return;
+          }
+          const otherFields = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (!isFilledValue(value)) {
+                return callback();
+              }
+              const hasAny = otherFields.some((field) => isFilledValue(getNestedValue(dataToValidate, field)));
+              if (hasAny) {
+                return callback(new Error(getMessage(fieldName, "prohibits", `${attributeName} prohibits ${otherFields.join(", ")}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "string":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (value === null || value === void 0) {
+                return callback();
+              }
+              if (typeof value !== "string") {
+                return callback(new Error(getMessage(fieldName, "string", `${attributeName} must be a string`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "nullable":
+          break;
         case "email":
           fieldRules.push({
             type: "email",
@@ -229,6 +630,53 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             transform: (value) => value?.trim()
           });
           break;
+        case "between": {
+          if (paramValues.length < 2) {
+            return;
+          }
+          const minValue = Number(paramValues[0]);
+          const maxValue = Number(paramValues[1]);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const size = getSizeValue(value);
+              if (size === null || Number.isNaN(minValue) || Number.isNaN(maxValue)) {
+                return callback(new Error(getMessage(fieldName, "between", `${attributeName} is invalid`)));
+              }
+              if (size < minValue || size > maxValue) {
+                return callback(new Error(getMessage(fieldName, "between", `${attributeName} must be between ${minValue} and ${maxValue}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "size": {
+          if (!firstParam) {
+            return;
+          }
+          const expected = Number(firstParam);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const size = getSizeValue(value);
+              if (size === null || Number.isNaN(expected)) {
+                return callback(new Error(getMessage(fieldName, "size", `${attributeName} is invalid`)));
+              }
+              if (size !== expected) {
+                return callback(new Error(getMessage(fieldName, "size", `${attributeName} must be ${expected}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
         case "same": {
           if (!firstParam) {
             return;
@@ -251,6 +699,15 @@ export const createValidationRules = (definitions, formState, options = {}) => {
           });
           break;
         }
+        case "date_format":
+          if (!params) {
+            return;
+          }
+          fieldRules.push({
+            validator: createDateFormatValidator(params, getMessage(fieldName, "date_format", `${attributeName} does not match the format ${params}`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
         case "date":
           fieldRules.push({
             validator: createDateValidator(getMessage(fieldName, "date", `${attributeName} must be a valid date in YYYY-MM-DD format`)),
@@ -283,6 +740,32 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             trigger: pickTrigger(fieldName, "blur")
           });
           break;
+        case "before_or_equal":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            validator: createDateComparisonValidator(
+              firstParam,
+              getMessage(fieldName, "before_or_equal", `${attributeName} must be a date before or equal to ${firstParam}`),
+              (valueDate, compareDate) => valueDate <= compareDate
+            ),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "after_or_equal":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            validator: createDateComparisonValidator(
+              firstParam,
+              getMessage(fieldName, "after_or_equal", `${attributeName} must be a date after or equal to ${firstParam}`),
+              (valueDate, compareDate) => valueDate >= compareDate
+            ),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
         case "alpha":
           fieldRules.push({
             validator: createPatternValidator(/^[a-z]+$/i, getMessage(fieldName, "alpha", `${attributeName} may only contain letters`)),
@@ -319,6 +802,88 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             trigger: pickTrigger(fieldName, "change")
           });
           break;
+        case "distinct":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (!Array.isArray(value)) {
+                return callback(new Error(getMessage(fieldName, "distinct", `${attributeName} must be an array`)));
+              }
+              const set = new Set(value.map((item) => JSON.stringify(item)));
+              if (set.size !== value.length) {
+                return callback(new Error(getMessage(fieldName, "distinct", `${attributeName} must not contain duplicates`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        case "in_array": {
+          if (!firstParam) {
+            return;
+          }
+          const otherField = firstParam;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const haystack = getNestedValue(dataToValidate, otherField);
+              if (!Array.isArray(haystack)) {
+                return callback(new Error(getMessage(fieldName, "in_array", `${attributeName} must be one of the values in ${otherField}`)));
+              }
+              if (!haystack.includes(value)) {
+                return callback(new Error(getMessage(fieldName, "in_array", `${attributeName} must be one of the values in ${otherField}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        }
+        case "required_array_keys": {
+          if (!paramValues.length) {
+            return;
+          }
+          const requiredKeys = paramValues;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback(new Error(getMessage(fieldName, "required_array_keys", `${attributeName} must include all required keys`)));
+              }
+              if (typeof value !== "object") {
+                return callback(new Error(getMessage(fieldName, "required_array_keys", `${attributeName} must be an array or object`)));
+              }
+              const missing = requiredKeys.filter((key) => !Object.prototype.hasOwnProperty.call(value, key));
+              if (missing.length) {
+                return callback(new Error(getMessage(fieldName, "required_array_keys", `${attributeName} must include keys: ${missing.join(", ")}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        }
+        case "list":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (!Array.isArray(value)) {
+                return callback(new Error(getMessage(fieldName, "list", `${attributeName} must be a list`)));
+              }
+              const isSequential = value.every((_, index) => Object.prototype.hasOwnProperty.call(value, index));
+              if (!isSequential) {
+                return callback(new Error(getMessage(fieldName, "list", `${attributeName} must be a list with sequential indices`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
         case "starts_with": {
           if (!paramValues.length) {
             return;
@@ -368,6 +933,85 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             trigger: pickTrigger(fieldName, "blur")
           });
           break;
+        case "lowercase":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (typeof value !== "string" || value !== value.toLowerCase()) {
+                return callback(new Error(getMessage(fieldName, "lowercase", `${attributeName} must be lowercase`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "uppercase":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (typeof value !== "string" || value !== value.toUpperCase()) {
+                return callback(new Error(getMessage(fieldName, "uppercase", `${attributeName} must be uppercase`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "uuid":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const text = String(value);
+              const pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+              if (!pattern.test(text)) {
+                return callback(new Error(getMessage(fieldName, "uuid", `${attributeName} must be a valid UUID`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "ulid":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const text = String(value);
+              const pattern = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
+              if (!pattern.test(text)) {
+                return callback(new Error(getMessage(fieldName, "ulid", `${attributeName} must be a valid ULID`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "timezone":
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              if (typeof value !== "string") {
+                return callback(new Error(getMessage(fieldName, "timezone", `${attributeName} must be a valid timezone`)));
+              }
+              try {
+                Intl.DateTimeFormat("en-US", { timeZone: value }).format();
+              } catch {
+                return callback(new Error(getMessage(fieldName, "timezone", `${attributeName} must be a valid timezone`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
         case "in": {
           if (!paramValues.length) {
             return;
@@ -379,6 +1023,51 @@ export const createValidationRules = (definitions, formState, options = {}) => {
           });
           break;
         }
+        case "multiple_of": {
+          if (!firstParam) {
+            return;
+          }
+          const factor = Number(firstParam);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const numeric = Number(value);
+              if (Number.isNaN(numeric) || Number.isNaN(factor) || factor === 0 || numeric % factor !== 0) {
+                return callback(new Error(getMessage(fieldName, "multiple_of", `${attributeName} must be a multiple of ${factor}`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "decimal": {
+          if (!paramValues.length) {
+            return;
+          }
+          const minDecimals = Number(paramValues[0]);
+          const maxDecimals = paramValues.length > 1 ? Number(paramValues[1]) : minDecimals;
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const text = String(value);
+              if (!/^-?\d+(?:\.\d+)?$/.test(text)) {
+                return callback(new Error(getMessage(fieldName, "decimal", `${attributeName} must be a decimal`)));
+              }
+              const decimals = text.includes(".") ? text.split(".")[1].length : 0;
+              if (decimals < minDecimals || decimals > maxDecimals) {
+                return callback(new Error(getMessage(fieldName, "decimal", `${attributeName} must have between ${minDecimals} and ${maxDecimals} decimal places`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
         case "numeric":
           fieldRules.push({
             validator: createNumericValidator(getMessage(fieldName, "numeric", `${attributeName} must be a number`)),
@@ -391,6 +1080,64 @@ export const createValidationRules = (definitions, formState, options = {}) => {
             trigger: pickTrigger(fieldName, "blur")
           });
           break;
+        case "confirmed": {
+          const confirmationField = getConfirmationField(fieldName);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const confirmationValue = getNestedValue(dataToValidate, confirmationField);
+              if (value !== confirmationValue) {
+                return callback(new Error(getMessage(fieldName, "confirmed", `${attributeName} confirmation does not match`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "digits": {
+          if (!firstParam) {
+            return;
+          }
+          const expectedLength = Number(firstParam);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const text = String(value);
+              if (!/^\d+$/.test(text) || text.length !== expectedLength) {
+                return callback(new Error(getMessage(fieldName, "digits", `${attributeName} must be ${expectedLength} digits`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "digits_between": {
+          if (paramValues.length < 2) {
+            return;
+          }
+          const minLength = Number(paramValues[0]);
+          const maxLength = Number(paramValues[1]);
+          fieldRules.push({
+            validator: (_rule, value, callback) => {
+              if (isEmptyValue(value)) {
+                return callback();
+              }
+              const text = String(value);
+              if (!/^\d+$/.test(text) || text.length < minLength || text.length > maxLength) {
+                return callback(new Error(getMessage(fieldName, "digits_between", `${attributeName} must be between ${minLength} and ${maxLength} digits`)));
+              }
+              callback();
+            },
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
         case "gt": {
           if (!firstParam) {
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciwergrp/nuxid",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "All-in-one essential modules for Nuxt",
   "repository": {
     "type": "git",