@excofy/utils 1.0.0

package/dist/index.js

@@ -0,0 +1,384 @@
+// src/helpers/sanitize.ts
+import { FilterXSS } from "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 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;
+    }
+  };
+}
+export {
+  createValidator,
+  htmlEntityDecode
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@excofy/utils",
+  "version": "1.0.0",
+  "description": "Biblioteca de utilitários para o Excofy",
+  "main": "dist/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs --out-dir dist",
+    "lint": "biome lint",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "deploy": "act"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/excofy/utils.git"
+  },
+  "keywords": [],
+  "author": "Excofy",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/excofy/utils/issues"
+  },
+  "homepage": "https://github.com/excofy/utils#readme",
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^24.0.3",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "xss": "^1.0.15"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/helpers/sanitize.ts

@@ -0,0 +1,115 @@
+import { type IWhiteList, FilterXSS } from 'xss';
+
+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;
+
+export type AllowedTag = Tag | { tag: Tag; attributes?: Attributes[] };
+
+const allTags: Tag[] = [
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'p',
+  'ul',
+  'ol',
+  'li',
+  'span',
+  'a',
+  'strong',
+  'em',
+  'i',
+  'br',
+  'img',
+];
+
+const allAttributes: Attributes[] = [
+  'data-lexical-text',
+  'style',
+  'dir',
+  'value',
+  'href',
+  'rel',
+  'target',
+  'alt',
+  'title',
+  'src',
+  'class',
+];
+
+export function sanitizeValue(
+  value: string,
+  allowedTags?: AllowedTag[]
+): string {
+  let whiteList: IWhiteList = {};
+
+  if (allowedTags === undefined) {
+    // Permitir todas as tags com todos os atributos
+    for (const tag of allTags) {
+      whiteList[tag] = [...allAttributes];
+    }
+  } else if (allowedTags.length === 0) {
+    // Não permitir nenhuma tag
+    whiteList = {};
+  } else {
+    // Construir whiteList com base nas tags e atributos permitidos explicitamente
+    for (const entry of allowedTags) {
+      if (typeof entry === 'string') {
+        whiteList[entry] = [];
+      } else {
+        whiteList[entry.tag] = entry.attributes ?? [];
+      }
+    }
+  }
+
+  const filter = new FilterXSS({
+    whiteList,
+    stripIgnoreTag: true,
+    stripIgnoreTagBody: ['script'],
+  });
+
+  return filter.process(value);
+}
+
+export function htmlEntityDecode(value?: string): string {
+  if (!value) {
+    return '';
+  }
+
+  return value
+    .replace(/>/g, '>')
+    .replace(/&lt;/g, '<')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+}