@excofy/utils 1.0.0

package/.eslintrc.json

@@ -0,0 +1,9 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended"
+  ]
+}

package/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish Package
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - name: Lint Code
+        run: npm run lint
+
+      - name: Build Package
+        run: npm run build
+
+      - name: Publish to NPM
+        uses: JS-DevTools/npm-publish@v3
+        with:
+          token: ${{ secrets.NPM_TOKEN }}

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "semi": true
+}

package/dist/index.cjs

@@ -0,0 +1,412 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createValidator: () => createValidator,
+  htmlEntityDecode: () => htmlEntityDecode
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/helpers/sanitize.ts
+var import_xss = require("xss");
+var allTags = [
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "p",
+  "ul",
+  "ol",
+  "li",
+  "span",
+  "a",
+  "strong",
+  "em",
+  "i",
+  "br",
+  "img"
+];
+var allAttributes = [
+  "data-lexical-text",
+  "style",
+  "dir",
+  "value",
+  "href",
+  "rel",
+  "target",
+  "alt",
+  "title",
+  "src",
+  "class"
+];
+function sanitizeValue(value, allowedTags) {
+  let whiteList = {};
+  if (allowedTags === void 0) {
+    for (const tag of allTags) {
+      whiteList[tag] = [...allAttributes];
+    }
+  } else if (allowedTags.length === 0) {
+    whiteList = {};
+  } else {
+    for (const entry of allowedTags) {
+      if (typeof entry === "string") {
+        whiteList[entry] = [];
+      } else {
+        whiteList[entry.tag] = entry.attributes ?? [];
+      }
+    }
+  }
+  const filter = new import_xss.FilterXSS({
+    whiteList,
+    stripIgnoreTag: true,
+    stripIgnoreTagBody: ["script"]
+  });
+  return filter.process(value);
+}
+function htmlEntityDecode(value) {
+  if (!value) {
+    return "";
+  }
+  return value.replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+
+// src/helpers/video.ts
+var video = {
+  youtube: {
+    isValid: (url) => {
+      const regex = /^(?:(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11}))/g;
+      return regex.test(url);
+    },
+    getId: (url) => {
+      const regex = /^(?:(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11}))/;
+      const match = url?.match(regex);
+      if (match && match.length >= 2 && match[1]) {
+        return match[1];
+      }
+      return null;
+    },
+    getEmbedUrl: (id) => {
+      return `https://www.youtube.com/embed/${id}`;
+    }
+  }
+};
+
+// src/helpers/validator.ts
+function createValidator() {
+  const current = {
+    field: "",
+    value: void 0,
+    required: false,
+    inputs: {},
+    errors: {},
+    typeValid: false,
+    setInput(field, value) {
+      this.field = field;
+      this.value = value;
+    },
+    pushError(message) {
+      const key = String(this.field);
+      if (!this.errors[key]) this.errors[key] = [];
+      this.errors[key].push({ message });
+    }
+  };
+  const validatorRequired = {
+    isRequired(message) {
+      current.required = true;
+      if (current.value === void 0 || current.value === null) {
+        current.pushError(message);
+      }
+      return validatorType;
+    },
+    isNotRequired() {
+      current.required = false;
+      return validatorType;
+    }
+  };
+  const validatorType = {
+    type(type, message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      const value = current.value;
+      let isValidType = false;
+      if (type === "array") {
+        isValidType = Array.isArray(value);
+      } else if (type === "object") {
+        isValidType = typeof value === "object" && value !== null && !Array.isArray(value);
+      } else if (type === "file") {
+        isValidType = value instanceof File;
+      } else if (type === "date") {
+        isValidType = typeof value === "string" && !Number.isNaN(new Date(value).getTime());
+      } else {
+        isValidType = type === "string" && typeof value === "string" || type === "number" && typeof value === "number" || type === "boolean" && typeof value === "boolean";
+      }
+      current.typeValid = isValidType;
+      if (!isValidType) {
+        current.pushError(message);
+      }
+      return validator;
+    }
+  };
+  const shouldSkipValidation = () => {
+    return !current.required && (current.value === void 0 || current.value === null || current.value === "");
+  };
+  const validator = {
+    each(callback) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (!Array.isArray(current.value)) return validator;
+      const fieldName = String(current.field);
+      for (let index = 0; index < current.value.length; index++) {
+        const item = current.value[index];
+        const subValidator = createValidator();
+        subValidator.setInputs(item);
+        callback(item, index, subValidator);
+        const subErrors = subValidator.getFlatErrors();
+        if (subErrors) {
+          for (const [subField, messages] of Object.entries(subErrors)) {
+            const path = `${fieldName}[${index}].${subField}`;
+            current.errors[path] = messages;
+          }
+        }
+        if (Array.isArray(current.value)) {
+          current.value[index] = subValidator.getSanitizedInputs();
+        }
+      }
+      current.inputs[current.field] = current.value;
+      return validator;
+    },
+    email: (message) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string") {
+        const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        if (!regex.test(current.value)) {
+          current.pushError(message);
+        }
+      } else {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    fileMaxSize: (maxSize, message) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      const value = current.value;
+      if (!(value instanceof File)) {
+        current.pushError("Arquivo inv\xE1lido");
+        return validator;
+      }
+      if (value.size > maxSize) {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    fileType: (validTypes, message) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      const value = current.value;
+      if (!(value instanceof File)) {
+        current.pushError("Arquivo inv\xE1lido");
+        return validator;
+      }
+      if (!validTypes.includes(value.type)) {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    length(length, message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      const value = current.value;
+      const isValid = (typeof value === "string" || Array.isArray(value)) && value.length === length;
+      if (!isValid) {
+        current.pushError(message);
+      }
+      return validator;
+    },
+    min(min, message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string" && current.value.length < min)
+        current.pushError(message);
+      else if (typeof current.value === "number" && current.value < min)
+        current.pushError(message);
+      else if (Array.isArray(current.value) && current.value.length < min)
+        current.pushError(message);
+      return validator;
+    },
+    max(max, message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string" && current.value.length > max)
+        current.pushError(message);
+      else if (typeof current.value === "number" && current.value > max)
+        current.pushError(message);
+      return validator;
+    },
+    transform(fn) {
+      if (shouldSkipValidation()) return validator;
+      const transformed = fn(current.value);
+      current.value = transformed;
+      current.inputs[current.field] = transformed;
+      return validator;
+    },
+    slug(message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string") {
+        const regex = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+        if (!regex.test(current.value)) current.pushError(message);
+      }
+      return validator;
+    },
+    sanitize() {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string") {
+        const newValue = sanitizeValue(current.value, []).replace(/\s+/g, " ").trim();
+        current.value = newValue;
+        current.inputs[current.field] = newValue;
+      }
+      return validator;
+    },
+    sanitizeHTML(tags) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string") {
+        const newValue = sanitizeValue(current.value, tags);
+        current.value = newValue;
+        current.inputs[current.field] = newValue;
+      }
+      return validator;
+    },
+    uuid(message) {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (typeof current.value === "string") {
+        const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (!regex.test(current.value)) current.pushError(message);
+      }
+      return validator;
+    },
+    oneOf: (types, message) => {
+      if (shouldSkipValidation()) {
+        return validator;
+      }
+      if (types.includes(String(current.value))) {
+        return validator;
+      }
+      current.pushError(message);
+      return validator;
+    },
+    videoUrl: {
+      youtube(message) {
+        if (shouldSkipValidation()) {
+          return validator;
+        }
+        if (typeof current.value === "string" && !video.youtube.isValid(current.value)) {
+          current.pushError(message);
+        }
+        return validator;
+      }
+    }
+  };
+  return {
+    getErrors() {
+      return Object.keys(current.errors).length > 0 ? current.errors : void 0;
+    },
+    getFlatErrors() {
+      const flatErrors = {};
+      function flatten(prefix, obj) {
+        if (!obj) return;
+        if (Array.isArray(obj)) {
+          if (obj.length > 0 && typeof obj[0] === "object" && "message" in obj[0]) {
+            flatErrors[prefix] = obj;
+          } else if (obj.length > 0 && typeof obj[0] === "object") {
+            for (let i = 0; i < obj.length; i++) {
+              flatten(`${prefix}[${i}]`, obj[i]);
+            }
+          }
+        } else {
+          for (const key in obj) {
+            flatten(prefix ? `${prefix}.${key}` : key, obj[key]);
+          }
+        }
+      }
+      flatten("", current.errors);
+      return Object.keys(flatErrors).length ? flatErrors : {};
+    },
+    getSanitizedInputs() {
+      return current.inputs;
+    },
+    hasErrors() {
+      return Object.keys(current.errors).length > 0;
+    },
+    setInputs(inputs) {
+      current.inputs = inputs;
+      current.errors = {};
+    },
+    unflattenErrors(flat) {
+      const result = {};
+      for (const flatKey in flat) {
+        const messages = flat[flatKey].map((m) => m.message).join("\n");
+        const pathParts = flatKey.replace(/\[(\d+)\]/g, ".$1").split(".");
+        let current2 = result;
+        for (let i = 0; i < pathParts.length; i++) {
+          const part = pathParts[i];
+          const nextIsIndex = /^\d+$/.test(pathParts[i + 1] || "");
+          if (i === pathParts.length - 1) {
+            current2[part] = messages;
+          } else {
+            if (!(part in current2)) {
+              current2[part] = nextIsIndex ? [] : {};
+            }
+            current2 = current2[part];
+          }
+        }
+      }
+      return result;
+    },
+    validate(field) {
+      current.setInput(field, current.inputs[field]);
+      return validatorRequired;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createValidator,
+  htmlEntityDecode
+});

package/dist/index.d.cts

@@ -0,0 +1,88 @@
+type Tag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'ul' | 'ol' | 'li' | 'span' | 'a' | 'strong' | 'em' | 'i' | 'br' | 'img';
+type LexicalEditorAttributes = 'data-lexical-text' | 'style' | 'dir' | 'value';
+type HTMLAttributes = 'href' | 'rel' | 'target' | 'alt' | 'title' | 'src' | 'class';
+type Attributes = LexicalEditorAttributes | HTMLAttributes;
+type AllowedTag = Tag | {
+    tag: Tag;
+    attributes?: Attributes[];
+};
+declare function htmlEntityDecode(value?: string): string;
+
+type TMessage = {
+    message: string;
+};
+type TValue = string | number | boolean | File | object | null | undefined;
+type TInputValue = TValue;
+type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'date';
+interface IInputErrors {
+    [key: string]: TMessage[] | IInputErrors[];
+}
+/**
+ * Cria um validador de inputs com suporte a validações encadeadas, transformação e sanitização.
+ *
+ * @template TRaw Tipo dos dados recebidos originalmente (geralmente string, vindo do query, body ou params).
+ * @template TParsed Tipo final retornado por `getValidatedInputs()` após transformações.
+ *
+ * @returns Um objeto com métodos para validação, transformação, sanitização e extração dos dados validados.
+ *
+ * @example
+ * type InputRaw = { limit?: string }
+ * type InputParsed = { limit?: number }
+ *
+ * const v = createValidator<InputRaw, InputParsed>()
+ * v.setInputs({ limit: '10' })
+ * v.validate('limit').type('string', 'Invalid').transform(Number)
+ * const inputs = v.getValidatedInputs() // { limit: 10 }
+ */
+declare function createValidator<TRaw extends Record<string, TInputValue>, TParsed = TRaw>(): {
+    getErrors(): IInputErrors | undefined;
+    getFlatErrors(): Record<string, TMessage[]>;
+    getSanitizedInputs(): TParsed;
+    hasErrors(): boolean;
+    setInputs(inputs: TRaw): void;
+    unflattenErrors(flat: Record<string, TMessage[]>): Record<string, unknown>;
+    validate<K extends keyof TRaw>(field: K): {
+        isRequired(message: string): {
+            type(type: TTypes, message: string): {
+                each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): /*elided*/ any;
+                email: (message: string) => /*elided*/ any;
+                fileMaxSize: (maxSize: number, message: string) => /*elided*/ any;
+                fileType: (validTypes: string[], message: string) => /*elided*/ any;
+                length(length: number, message: string): /*elided*/ any;
+                min(min: number, message: string): /*elided*/ any;
+                max(max: number, message: string): /*elided*/ any;
+                transform<U>(fn: (value: TInputValue) => U): /*elided*/ any;
+                slug(message: string): /*elided*/ any;
+                sanitize(): /*elided*/ any;
+                sanitizeHTML(tags?: AllowedTag[]): /*elided*/ any;
+                uuid(message: string): /*elided*/ any;
+                oneOf: (types: string[], message: string) => /*elided*/ any;
+                videoUrl: {
+                    youtube(message: string): /*elided*/ any;
+                };
+            };
+        };
+        isNotRequired(): {
+            type(type: TTypes, message: string): {
+                each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): /*elided*/ any;
+                email: (message: string) => /*elided*/ any;
+                fileMaxSize: (maxSize: number, message: string) => /*elided*/ any;
+                fileType: (validTypes: string[], message: string) => /*elided*/ any;
+                length(length: number, message: string): /*elided*/ any;
+                min(min: number, message: string): /*elided*/ any;
+                max(max: number, message: string): /*elided*/ any;
+                transform<U>(fn: (value: TInputValue) => U): /*elided*/ any;
+                slug(message: string): /*elided*/ any;
+                sanitize(): /*elided*/ any;
+                sanitizeHTML(tags?: AllowedTag[]): /*elided*/ any;
+                uuid(message: string): /*elided*/ any;
+                oneOf: (types: string[], message: string) => /*elided*/ any;
+                videoUrl: {
+                    youtube(message: string): /*elided*/ any;
+                };
+            };
+        };
+    };
+};
+
+export { createValidator, htmlEntityDecode };

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+type Tag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'p' | 'ul' | 'ol' | 'li' | 'span' | 'a' | 'strong' | 'em' | 'i' | 'br' | 'img';
+type LexicalEditorAttributes = 'data-lexical-text' | 'style' | 'dir' | 'value';
+type HTMLAttributes = 'href' | 'rel' | 'target' | 'alt' | 'title' | 'src' | 'class';
+type Attributes = LexicalEditorAttributes | HTMLAttributes;
+type AllowedTag = Tag | {
+    tag: Tag;
+    attributes?: Attributes[];
+};
+declare function htmlEntityDecode(value?: string): string;
+
+type TMessage = {
+    message: string;
+};
+type TValue = string | number | boolean | File | object | null | undefined;
+type TInputValue = TValue;
+type TTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'file' | 'date';
+interface IInputErrors {
+    [key: string]: TMessage[] | IInputErrors[];
+}
+/**
+ * Cria um validador de inputs com suporte a validações encadeadas, transformação e sanitização.
+ *
+ * @template TRaw Tipo dos dados recebidos originalmente (geralmente string, vindo do query, body ou params).
+ * @template TParsed Tipo final retornado por `getValidatedInputs()` após transformações.
+ *
+ * @returns Um objeto com métodos para validação, transformação, sanitização e extração dos dados validados.
+ *
+ * @example
+ * type InputRaw = { limit?: string }
+ * type InputParsed = { limit?: number }
+ *
+ * const v = createValidator<InputRaw, InputParsed>()
+ * v.setInputs({ limit: '10' })
+ * v.validate('limit').type('string', 'Invalid').transform(Number)
+ * const inputs = v.getValidatedInputs() // { limit: 10 }
+ */
+declare function createValidator<TRaw extends Record<string, TInputValue>, TParsed = TRaw>(): {
+    getErrors(): IInputErrors | undefined;
+    getFlatErrors(): Record<string, TMessage[]>;
+    getSanitizedInputs(): TParsed;
+    hasErrors(): boolean;
+    setInputs(inputs: TRaw): void;
+    unflattenErrors(flat: Record<string, TMessage[]>): Record<string, unknown>;
+    validate<K extends keyof TRaw>(field: K): {
+        isRequired(message: string): {
+            type(type: TTypes, message: string): {
+                each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): /*elided*/ any;
+                email: (message: string) => /*elided*/ any;
+                fileMaxSize: (maxSize: number, message: string) => /*elided*/ any;
+                fileType: (validTypes: string[], message: string) => /*elided*/ any;
+                length(length: number, message: string): /*elided*/ any;
+                min(min: number, message: string): /*elided*/ any;
+                max(max: number, message: string): /*elided*/ any;
+                transform<U>(fn: (value: TInputValue) => U): /*elided*/ any;
+                slug(message: string): /*elided*/ any;
+                sanitize(): /*elided*/ any;
+                sanitizeHTML(tags?: AllowedTag[]): /*elided*/ any;
+                uuid(message: string): /*elided*/ any;
+                oneOf: (types: string[], message: string) => /*elided*/ any;
+                videoUrl: {
+                    youtube(message: string): /*elided*/ any;
+                };
+            };
+        };
+        isNotRequired(): {
+            type(type: TTypes, message: string): {
+                each(callback: <U extends Record<string, TInputValue>>(item: U, index: number, subValidator: ReturnType<typeof createValidator<U>>) => void): /*elided*/ any;
+                email: (message: string) => /*elided*/ any;
+                fileMaxSize: (maxSize: number, message: string) => /*elided*/ any;
+                fileType: (validTypes: string[], message: string) => /*elided*/ any;
+                length(length: number, message: string): /*elided*/ any;
+                min(min: number, message: string): /*elided*/ any;
+                max(max: number, message: string): /*elided*/ any;
+                transform<U>(fn: (value: TInputValue) => U): /*elided*/ any;
+                slug(message: string): /*elided*/ any;
+                sanitize(): /*elided*/ any;
+                sanitizeHTML(tags?: AllowedTag[]): /*elided*/ any;
+                uuid(message: string): /*elided*/ any;
+                oneOf: (types: string[], message: string) => /*elided*/ any;
+                videoUrl: {
+                    youtube(message: string): /*elided*/ any;
+                };
+            };
+        };
+    };
+};
+
+export { createValidator, htmlEntityDecode };