@ciwergrp/nuxid 1.0.2-release

package/dist/runtime/validator.js

@@ -0,0 +1,445 @@
+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));
+    } else {
+      callback();
+    }
+  };
+};
+const createPatternValidator = (pattern, message) => {
+  return (_rule, value, callback) => {
+    if (value && !pattern.test(value)) {
+      callback(new Error(message));
+    } else {
+      callback();
+    }
+  };
+};
+const createNumericValidator = (message) => {
+  return (_rule, value, callback) => {
+    if (value && Number.isNaN(Number(value))) {
+      callback(new Error(message));
+    } else {
+      callback();
+    }
+  };
+};
+const createIntegerValidator = (message) => {
+  return (_rule, value, callback) => {
+    if (value && !Number.isInteger(Number(value))) {
+      callback(new Error(message));
+    } else {
+      callback();
+    }
+  };
+};
+const createComparisonValidator = (otherField, formState, message, compare) => {
+  return (_rule, value, callback) => {
+    const otherValue = formState[otherField];
+    if (value && otherValue && !compare(value, otherValue)) {
+      callback(new Error(message));
+    } else {
+      callback();
+    }
+  };
+};
+const createDateValidator = (message) => {
+  return (_rule, value, callback) => {
+    if (!value) {
+      return callback();
+    }
+    const pattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!pattern.test(value)) {
+      return callback(new Error(message));
+    }
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createDateComparisonValidator = (compareDate, message, compare) => {
+  return (_rule, value, callback) => {
+    if (!value) {
+      return callback();
+    }
+    const pattern = /^\d{4}-\d{2}-\d{2}$/;
+    if (!pattern.test(value)) {
+      return callback(new Error(message));
+    }
+    const valueDate = new Date(value);
+    if (Number.isNaN(valueDate.getTime())) {
+      return callback(new Error(message));
+    }
+    const comparisonDate = new Date(compareDate);
+    if (Number.isNaN(comparisonDate.getTime())) {
+      return callback(new Error(`Invalid comparison date: ${compareDate}`));
+    }
+    if (!compare(valueDate, comparisonDate)) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createArrayValidator = (message) => {
+  return (_rule, value, callback) => {
+    if (value === null || value === void 0) {
+      return callback();
+    }
+    if (!Array.isArray(value)) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createURLValidator = (message) => {
+  return (_rule, value, callback) => {
+    if (!value) {
+      return callback();
+    }
+    try {
+      const parsed = new URL(value);
+      if (!["http:", "https:"].includes(parsed.protocol)) {
+        return callback(new Error(message));
+      }
+    } catch {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createIPValidator = (message) => {
+  const ipv4 = /^(?:25[0-5]|2[0-4]\d|[01]?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d?\d)){3}$/;
+  const ipv6 = /^(?:(?:[0-9a-f]{1,4}:){7}[0-9a-f]{1,4}|::1|::)$/i;
+  return (_rule, value, callback) => {
+    if (!value) {
+      return callback();
+    }
+    if (typeof value !== "string") {
+      return callback(new Error(message));
+    }
+    if (!ipv4.test(value) && !ipv6.test(value)) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createHexColorValidator = (message) => {
+  const pattern = /^#?(?:[A-F0-9]{6}|[A-F0-9]{3})$/i;
+  return (_rule, value, callback) => {
+    if (!value) {
+      return callback();
+    }
+    if (typeof value !== "string" || !pattern.test(value)) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+const createInValidator = (allowed, message) => {
+  const allowedSet = new Set(allowed);
+  return (_rule, value, callback) => {
+    if (value === void 0 || value === null || value === "") {
+      return callback();
+    }
+    if (!allowedSet.has(String(value))) {
+      return callback(new Error(message));
+    }
+    callback();
+  };
+};
+export const createValidationRules = (definitions, formState, options = {}) => {
+  const { messages = {}, attributes = {}, authorize, prepareForValidation } = options;
+  const fieldTriggers = options.trigger || {};
+  const pickTrigger = (f, defaultTrig) => {
+    return fieldTriggers[f] ?? defaultTrig;
+  };
+  if (authorize && !authorize()) {
+    throw new Error("This action is unauthorized.");
+  }
+  let dataToValidate = { ...formState };
+  if (prepareForValidation) {
+    dataToValidate = prepareForValidation(dataToValidate);
+  }
+  const rules = {};
+  const getMessage = (fieldName, rule, defaultMessage) => {
+    const customMessageKey = `${fieldName}.${rule}`;
+    return messages[customMessageKey] || defaultMessage;
+  };
+  for (const fieldName in definitions) {
+    const fieldDefinition = definitions[fieldName];
+    if (!fieldDefinition) {
+      continue;
+    }
+    let laravelRules;
+    if ("sometimes" in fieldDefinition && typeof fieldDefinition.sometimes === "function") {
+      if (!fieldDefinition.sometimes(dataToValidate)) {
+        continue;
+      }
+      laravelRules = fieldDefinition.rules;
+    } else {
+      laravelRules = fieldDefinition;
+    }
+    const fieldRules = [];
+    const attributeName = attributes[fieldName] || fieldName;
+    laravelRules.forEach((ruleString) => {
+      const [rule, params] = ruleString.split(":");
+      const paramValues = params?.split(",") ?? [];
+      const firstParam = paramValues[0] ?? "";
+      switch (rule) {
+        case "required":
+          fieldRules.push({
+            required: true,
+            message: getMessage(fieldName, "required", `${attributeName} is required`),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "email":
+          fieldRules.push({
+            type: "email",
+            message: getMessage(fieldName, "email", "Please provide a valid email address"),
+            trigger: pickTrigger(fieldName, ["blur", "change"])
+          });
+          break;
+        case "min":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            min: Number(firstParam),
+            message: getMessage(fieldName, "min", `${attributeName} must be at least ${firstParam} characters`),
+            trigger: pickTrigger(fieldName, "blur"),
+            transform: (value) => value?.trim()
+          });
+          break;
+        case "max":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            max: Number(firstParam),
+            message: getMessage(fieldName, "max", `${attributeName} cannot be more than ${firstParam} characters`),
+            trigger: pickTrigger(fieldName, "blur"),
+            transform: (value) => value?.trim()
+          });
+          break;
+        case "same": {
+          if (!firstParam) {
+            return;
+          }
+          const sameOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createSameAsValidator(firstParam, dataToValidate, getMessage(fieldName, "same", `${attributeName} must match ${sameOtherAttr}`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "different": {
+          if (!firstParam) {
+            return;
+          }
+          const diffOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createComparisonValidator(firstParam, dataToValidate, getMessage(fieldName, "different", `${attributeName} must be different from ${diffOtherAttr}`), (a, b) => a !== b),
+            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`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "before":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            validator: createDateComparisonValidator(
+              firstParam,
+              getMessage(fieldName, "before", `${attributeName} must be a date before ${firstParam}`),
+              (valueDate, compareDate) => valueDate < compareDate
+            ),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "after":
+          if (!firstParam) {
+            return;
+          }
+          fieldRules.push({
+            validator: createDateComparisonValidator(
+              firstParam,
+              getMessage(fieldName, "after", `${attributeName} must be a date after ${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`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "alpha_num":
+          fieldRules.push({
+            validator: createPatternValidator(/^[a-z0-9]+$/i, getMessage(fieldName, "alpha_num", `${attributeName} may only contain letters and numbers`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "alpha_dash":
+          fieldRules.push({
+            validator: createPatternValidator(/^[\w-]+$/, getMessage(fieldName, "alpha_dash", `${attributeName} may only contain letters, numbers, dashes, and underscores`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "alphanumeric_space":
+          fieldRules.push({
+            validator: createPatternValidator(/^[\w -]+$/, getMessage(fieldName, "alphanumeric_space", `${attributeName} may only contain letters, numbers, spaces, dashes, and underscores`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "alpha_space":
+          fieldRules.push({
+            validator: createPatternValidator(/^[a-z _-]+$/i, getMessage(fieldName, "alpha_space", `${attributeName} may only contain letters, spaces, dashes, and underscores`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "array":
+          fieldRules.push({
+            validator: createArrayValidator(getMessage(fieldName, "array", `${attributeName} must be an array`)),
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        case "starts_with": {
+          if (!paramValues.length) {
+            return;
+          }
+          const startsWithPattern = new RegExp(`^(?:${paramValues.join("|")})`);
+          fieldRules.push({
+            validator: createPatternValidator(startsWithPattern, getMessage(fieldName, "starts_with", `${attributeName} must start with one of the following: ${paramValues.join(", ")}`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "ends_with": {
+          if (!paramValues.length) {
+            return;
+          }
+          const endsWithPattern = new RegExp(`(?:${paramValues.join("|")})$`);
+          fieldRules.push({
+            validator: createPatternValidator(endsWithPattern, getMessage(fieldName, "ends_with", `${attributeName} must end with one of the following: ${paramValues.join(", ")}`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "regex":
+          if (!params) {
+            return;
+          }
+          fieldRules.push({
+            validator: createPatternValidator(new RegExp(params), getMessage(fieldName, "regex", `${attributeName} format is invalid`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "url":
+          fieldRules.push({
+            validator: createURLValidator(getMessage(fieldName, "url", `${attributeName} must be a valid URL (http/https)`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "ip":
+          fieldRules.push({
+            validator: createIPValidator(getMessage(fieldName, "ip", `${attributeName} must be a valid IP address`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "hex_color":
+          fieldRules.push({
+            validator: createHexColorValidator(getMessage(fieldName, "hex_color", `${attributeName} must be a valid hex color`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "in": {
+          if (!paramValues.length) {
+            return;
+          }
+          const allowedValues = paramValues ?? [];
+          fieldRules.push({
+            validator: createInValidator(allowedValues, getMessage(fieldName, "in", `${attributeName} must be one of: ${allowedValues.join(", ")}`)),
+            trigger: pickTrigger(fieldName, "change")
+          });
+          break;
+        }
+        case "numeric":
+          fieldRules.push({
+            validator: createNumericValidator(getMessage(fieldName, "numeric", `${attributeName} must be a number`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "integer":
+          fieldRules.push({
+            validator: createIntegerValidator(getMessage(fieldName, "integer", `${attributeName} must be an integer`)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        case "gt": {
+          if (!firstParam) {
+            return;
+          }
+          const gtOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createComparisonValidator(firstParam, dataToValidate, getMessage(fieldName, "gt", `${attributeName} must be greater than ${gtOtherAttr}`), (a, b) => Number(a) > Number(b)),
+            trigger: pickTrigger(fieldName, "blur")
+          });
+          break;
+        }
+        case "gte": {
+          if (!firstParam) {
+            return;
+          }
+          const gteOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createComparisonValidator(firstParam, dataToValidate, getMessage(fieldName, "gte", `${attributeName} must be greater than or equal to ${gteOtherAttr}`), (a, b) => Number(a) >= Number(b)),
+            trigger: "blur"
+          });
+          break;
+        }
+        case "lt": {
+          if (!firstParam) {
+            return;
+          }
+          const ltOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createComparisonValidator(firstParam, dataToValidate, getMessage(fieldName, "lt", `${attributeName} must be less than ${ltOtherAttr}`), (a, b) => Number(a) < Number(b)),
+            trigger: "blur"
+          });
+          break;
+        }
+        case "lte": {
+          if (!firstParam) {
+            return;
+          }
+          const lteOtherAttr = attributes[firstParam] || firstParam;
+          fieldRules.push({
+            validator: createComparisonValidator(firstParam, dataToValidate, getMessage(fieldName, "lte", `${attributeName} must be less than or equal to ${lteOtherAttr}`), (a, b) => Number(a) <= Number(b)),
+            trigger: "blur"
+          });
+          break;
+        }
+        case "bail":
+          break;
+      }
+    });
+    rules[fieldName] = fieldRules;
+  }
+  return rules;
+};

package/dist/types.d.mts

@@ -0,0 +1,11 @@
+export { type useForm } from '../dist/runtime/form.js'
+
+export { default } from './module.mjs'
+
+export { type ModuleOptions } from './module.mjs'
+
+export * from '../dist/runtime/form.js'
+
+export * from '../dist/runtime/validator.js'
+
+export * from '../dist/runtime/helper/index.js'

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@ciwergrp/nuxid",
+  "version": "1.0.2-release",
+  "description": "All-in-one essential modules for Nuxt",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/ciwergrp/nuxid.git"
+  },
+  "keywords": [
+    "nuxt",
+    "essentials",
+    "nuxid"
+  ],
+  "author": {
+    "name": "Bagus",
+    "email": "bagusp81@gmail.com"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
+  "bin": {
+    "kiban": "./bin/kiban.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "console",
+    "package.json",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@element-plus/nuxt": "1.1.4",
+    "@formatjs/intl": "4.0.7",
+    "@inquirer/prompts": "8.1.0",
+    "@nuxt/icon": "2.1.1",
+    "@nuxt/kit": "4.2.2",
+    "@sentry/nuxt": "10.32.1",
+    "@sindresorhus/slugify": "3.0.0",
+    "@sindresorhus/transliterate": "2.3.0",
+    "@vueuse/nuxt": "14.1.0",
+    "element-plus": "2.13.0",
+    "hls.js": "1.6.15",
+    "lodash-es": "4.17.22",
+    "moment": "2.30.1",
+    "pinia": "3.0.4",
+    "pluralize": "8.0.0",
+    "socket.io-client": "4.8.3"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.0",
+    "@nuxt/eslint-config": "^1.10.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.2.1",
+    "@nuxt/test-utils": "^3.20.1",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.1",
+    "nuxt": "^4.2.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.13",
+    "vue-tsc": "^3.1.5"
+  },
+  "scripts": {
+    "dev": "npm run dev:prepare && nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  }
+}