@caipira/tamandua 0.0.1

package/services/password.ts

@@ -0,0 +1,309 @@
+const getPasswordStrength = (pwd: string) => {
+    let nScore = 0;
+    let nLength = 0;
+    let nAlphaUC = 0;
+    let nAlphaLC = 0;
+    let nNumber = 0;
+    let nSymbol = 0;
+    let nMidChar = 0;
+    let nRequirements = 0;
+    let nAlphasOnly = 0;
+    let nNumbersOnly = 0;
+    let nUnqChar = 0;
+    let nRepChar = 0;
+    let nRepInc = 0;
+    let nConsecAlphaUC = 0;
+    let nConsecAlphaLC = 0;
+    let nConsecNumber = 0;
+    let nConsecSymbol = 0;
+    let nConsecCharType = 0;
+    let nSeqAlpha = 0;
+    let nSeqNumber = 0;
+    let nSeqSymbol = 0;
+    let nSeqChar = 0;
+    let nReqChar = 0;
+    let nMultMidChar = 2;
+    let nMultConsecAlphaUC = 2;
+    let nMultConsecAlphaLC = 2;
+    let nMultConsecNumber = 2;
+    let nMultSeqAlpha = 3;
+    let nMultSeqNumber = 3;
+    let nMultSeqSymbol = 3;
+    let nMultLength = 4;
+    let nMultNumber = 4;
+    let nMultSymbol = 6;
+    let nTmpAlphaUC = "";
+    let nTmpAlphaLC = "";
+    let nTmpNumber = "";
+    let nTmpSymbol = "";
+    let sAlphaUC = "0";
+    let sAlphaLC = "0";
+    let sNumber = "0";
+    let sSymbol = "0";
+    let sMidChar = "0";
+    let sRequirements = "0";
+    let sAlphasOnly = "0";
+    let sNumbersOnly = "0";
+    let sRepChar = "0";
+    let sConsecAlphaUC = "0";
+    let sConsecAlphaLC = "0";
+    let sConsecNumber = "0";
+    let sSeqAlpha = "0";
+    let sSeqNumber = "0";
+    let sSeqSymbol = "0";
+    let sComplexity = "Too Short";
+    const sAlphas = "abcdefghijklmnopqrstuvwxyz";
+    const sNumerics = "01234567890";
+    const sSymbols = ")!@#$%^&*()";
+    const nMinPwdLen = 8;
+    const arrPwd = pwd.replace(/\s+/g, "").split(/\s*/);
+    const arrPwdLen = arrPwd.length;
+
+    nScore = pwd.length * nMultLength;
+    nLength = pwd.length;
+
+    /* Loop through password to check for Symbol, Numeric, Lowercase and Uppercase pattern matches */
+    for (let a = 0; a < arrPwdLen; a++) {
+        if (arrPwd[a].match(/[A-Z]/g)) {
+            if (nTmpAlphaUC !== "") {
+                if (nTmpAlphaUC + 1 == a) {
+                    nConsecAlphaUC++;
+                    nConsecCharType++;
+                }
+            }
+
+            nTmpAlphaUC = a;
+            nAlphaUC++;
+        } else if (arrPwd[a].match(/[a-z]/g)) {
+            if (nTmpAlphaLC !== "") {
+                if (nTmpAlphaLC + 1 == a) {
+                    nConsecAlphaLC++;
+                    nConsecCharType++;
+                }
+            }
+
+            nTmpAlphaLC = a;
+            nAlphaLC++;
+        } else if (arrPwd[a].match(/[0-9]/g)) {
+            if (a > 0 && a < arrPwdLen - 1) {
+                nMidChar++;
+            }
+            if (nTmpNumber !== "") {
+                if (nTmpNumber + 1 == a) {
+                    nConsecNumber++;
+                    nConsecCharType++;
+                }
+            }
+
+            nTmpNumber = a;
+            nNumber++;
+        } else if (arrPwd[a].match(/[^a-zA-Z0-9_]/g)) {
+            if (a > 0 && a < arrPwdLen - 1) {
+                nMidChar++;
+            }
+
+            if (nTmpSymbol !== "") {
+                if (nTmpSymbol + 1 == a) {
+                    nConsecSymbol++;
+                    nConsecCharType++;
+                }
+            }
+
+            nTmpSymbol = a;
+            nSymbol++;
+        }
+
+        /* Internal loop through password to check for repeat characters */
+        let bCharExists = false;
+        for (let b = 0; b < arrPwdLen; b++) {
+            if (arrPwd[a] == arrPwd[b] && a != b) {
+                // repeat character exists
+                bCharExists = true;
+
+                /**
+                 * Calculate icrement deduction based on proximity to identical characters
+                 * Deduction is incremented each time a new match is discovered
+                 * Deduction amount is based on total password length divided by the
+                 * difference of distance between currently selected match
+                 */
+                nRepInc += Math.abs(arrPwdLen / (b - a));
+            }
+        }
+
+        if (bCharExists) {
+            nRepChar++;
+            nUnqChar = arrPwdLen - nRepChar;
+            nRepInc = nUnqChar
+                ? Math.ceil(nRepInc / nUnqChar)
+                : Math.ceil(nRepInc);
+        }
+    }
+
+    /* Check for sequential alpha string patterns (forward and reverse) */
+    for (let s = 0; s < 23; s++) {
+        let sFwd = sAlphas.substring(s, parseInt(s + 3));
+        let sRev = sFwd.split("").reverse().join("");
+
+        if (
+            pwd.toLowerCase().indexOf(sFwd) != -1 ||
+            pwd.toLowerCase().indexOf(sRev) != -1
+        ) {
+            nSeqAlpha++;
+            nSeqChar++;
+        }
+    }
+
+    /* Check for sequential numeric string patterns (forward and reverse) */
+    for (let s = 0; s < 8; s++) {
+        let sFwd = sNumerics.substring(s, parseInt(s + 3));
+        var sRev = sFwd.split("").reverse().join("");
+
+        if (
+            pwd.toLowerCase().indexOf(sFwd) != -1 ||
+            pwd.toLowerCase().indexOf(sRev) != -1
+        ) {
+            nSeqNumber++;
+            nSeqChar++;
+        }
+    }
+
+    /* Check for sequential symbol string patterns (forward and reverse) */
+    for (let s = 0; s < 8; s++) {
+        let sFwd = sSymbols.substring(s, parseInt(s + 3));
+        let sRev = sFwd.split("").reverse().join("");
+
+        if (
+            pwd.toLowerCase().indexOf(sFwd) != -1 ||
+            pwd.toLowerCase().indexOf(sRev) != -1
+        ) {
+            nSeqSymbol++;
+            nSeqChar++;
+        }
+    }
+
+    /* General point assignment */
+    if (nAlphaUC > 0 && nAlphaUC < nLength) {
+        nScore = parseInt(nScore + (nLength - nAlphaUC) * 2);
+        sAlphaUC = "+ " + parseInt((nLength - nAlphaUC) * 2);
+    }
+
+    if (nAlphaLC > 0 && nAlphaLC < nLength) {
+        nScore = parseInt(nScore + (nLength - nAlphaLC) * 2);
+        sAlphaLC = "+ " + parseInt((nLength - nAlphaLC) * 2);
+    }
+
+    if (nNumber > 0 && nNumber < nLength) {
+        nScore = parseInt(nScore + nNumber * nMultNumber);
+        sNumber = "+ " + parseInt(nNumber * nMultNumber);
+    }
+
+    if (nSymbol > 0) {
+        nScore = parseInt(nScore + nSymbol * nMultSymbol);
+        sSymbol = "+ " + parseInt(nSymbol * nMultSymbol);
+    }
+
+    if (nMidChar > 0) {
+        nScore = parseInt(nScore + nMidChar * nMultMidChar);
+        sMidChar = "+ " + parseInt(nMidChar * nMultMidChar);
+    }
+
+    /* Point deductions for poor practices */
+    if ((nAlphaLC > 0 || nAlphaUC > 0) && nSymbol === 0 && nNumber === 0) {
+        // Only Letters
+        nScore = parseInt(nScore - nLength);
+        nAlphasOnly = nLength;
+        sAlphasOnly = "- " + nLength;
+    }
+
+    if (nAlphaLC === 0 && nAlphaUC === 0 && nSymbol === 0 && nNumber > 0) {
+        // Only Numbers
+        nScore = parseInt(nScore - nLength);
+        nNumbersOnly = nLength;
+        sNumbersOnly = "- " + nLength;
+    }
+
+    if (nRepChar > 0) {
+        // Same character exists more than once
+        nScore = parseInt(nScore - nRepInc);
+        sRepChar = "- " + nRepInc;
+    }
+
+    if (nConsecAlphaUC > 0) {
+        // Consecutive Uppercase Letters exist
+        nScore = parseInt(nScore - nConsecAlphaUC * nMultConsecAlphaUC);
+        sConsecAlphaUC = "- " + parseInt(nConsecAlphaUC * nMultConsecAlphaUC);
+    }
+
+    if (nConsecAlphaLC > 0) {
+        // Consecutive Lowercase Letters exist
+        nScore = parseInt(nScore - nConsecAlphaLC * nMultConsecAlphaLC);
+        sConsecAlphaLC = "- " + parseInt(nConsecAlphaLC * nMultConsecAlphaLC);
+    }
+
+    if (nConsecNumber > 0) {
+        // Consecutive Numbers exist
+        nScore = parseInt(nScore - nConsecNumber * nMultConsecNumber);
+        sConsecNumber = "- " + parseInt(nConsecNumber * nMultConsecNumber);
+    }
+
+    if (nSeqAlpha > 0) {
+        // Sequential alpha strings exist (3 characters or more)
+        nScore = parseInt(nScore - nSeqAlpha * nMultSeqAlpha);
+        sSeqAlpha = "- " + parseInt(nSeqAlpha * nMultSeqAlpha);
+    }
+
+    if (nSeqNumber > 0) {
+        // Sequential numeric strings exist (3 characters or more)
+        nScore = parseInt(nScore - nSeqNumber * nMultSeqNumber);
+        sSeqNumber = "- " + parseInt(nSeqNumber * nMultSeqNumber);
+    }
+
+    if (nSeqSymbol > 0) {
+        // Sequential symbol strings exist (3 characters or more)
+        nScore = parseInt(nScore - nSeqSymbol * nMultSeqSymbol);
+        sSeqSymbol = "- " + parseInt(nSeqSymbol * nMultSeqSymbol);
+    }
+
+    nRequirements = nReqChar;
+    let nMinReqChars = 0;
+
+    if (pwd.length >= nMinPwdLen) {
+        nMinReqChars = 3;
+    } else {
+        nMinReqChars = 4;
+    }
+
+    if (nRequirements > nMinReqChars) {
+        // One or more required characters exist
+        nScore = parseInt(nScore + nRequirements * 2);
+        sRequirements = "+ " + parseInt(nRequirements * 2);
+    }
+
+    /* Determine complexity based on overall score */
+    if (nScore > 100) {
+        nScore = 100;
+    } else if (nScore < 0) {
+        nScore = 0;
+    }
+
+    if (nScore >= 0 && nScore < 20) {
+        sComplexity = "Very Weak";
+    } else if (nScore >= 20 && nScore < 40) {
+        sComplexity = "Weak";
+    } else if (nScore >= 40 && nScore < 60) {
+        sComplexity = "Good";
+    } else if (nScore >= 60 && nScore < 80) {
+        sComplexity = "Strong";
+    } else if (nScore >= 80 && nScore <= 100) {
+        sComplexity = "Very Strong";
+    }
+
+    return {
+        score: nScore,
+        complexity: sComplexity,
+    };
+};
+
+export default {
+    getPasswordStrength,
+};

package/services/ui.ts

@@ -0,0 +1,43 @@
+import type { ComponentInternalInstance } from "vue";
+
+export default {
+    popoverActivatorEvent: "popoverClick",
+
+    wasClickOutsideOfContainer(event: MouseEvent, container: HTMLElement) {
+        let targetElement: HTMLElement | null = event.target as HTMLElement;
+
+        if (!targetElement) {
+            return false;
+        }
+
+        do {
+            if (targetElement === container) {
+                event.stopPropagation();
+
+                return false;
+            }
+
+            targetElement = targetElement?.parentNode as HTMLElement | null;
+        } while (targetElement);
+
+        return true;
+    },
+
+    isPopoverActivator(instance?: ComponentInternalInstance): boolean {
+        if (!instance?.parent || !instance?.parent?.emitsOptions) {
+            return false;
+        }
+
+        return this.popoverActivatorEvent in instance.parent.emitsOptions;
+    },
+
+    onPopoverActivatorClick(event: MouseEvent, el: any): void {
+        if (this.isPopoverActivator(el)) {
+            el.parent.emit(this.popoverActivatorEvent, event);
+        }
+
+        // Make sure not to propagate this further, as it'll also trigger a click event
+        // in the parent component
+        event.stopPropagation();
+    },
+};

package/tailwind.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  content: ['./index.html', './components/**/*.vue'],
+  darkMode: 'class',
+  theme: {
+    extend: {
+      minHeight: {
+        9: '2.25rem',
+      },
+    },
+  },
+  plugins: [
+    require('@tailwindcss/forms')({
+      strategy: 'class',
+    }),
+  ],
+};

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "experimentalDecorators": true,
+        "target": "esnext",
+        "useDefineForClassFields": true,
+        "module": "esnext",
+        "moduleResolution": "node",
+        "strict": true,
+        "sourceMap": true,
+        "resolveJsonModule": true,
+        "noImplicitAny": false,
+        "allowJs": true,
+        "esModuleInterop": true,
+        "lib": ["esnext", "dom", "dom.iterable"],
+        "baseUrl": ".",
+        "types": ["node", "vite/client", "vitest/globals"],
+        "paths": {
+            "@/*": ["./*"]
+        }
+    },
+    "include": ["./**/*.ts", "./**/*.vue", "vite.config.mts"],
+    "exclude": ["node_modules"]
+}

package/types/address.ts

@@ -0,0 +1,44 @@
+export interface Country {
+    name: string;
+    dialCode: string;
+    flag: string;
+    iso2: string;
+    order: string;
+}
+
+export interface CountryStateOption {
+    uuid: string;
+    name: string;
+}
+
+/* Response & Payload from/to the API  */
+export interface AddressResource {
+    city?: string;
+    complement?: string;
+    country?: string;
+    county?: string;
+    id?: string;
+    neighborhood?: string;
+    number?: string;
+    province?: string;
+    state?: string;
+    street?: string;
+    town?: string;
+    zipCode?: string;
+}
+
+/* Model for InputAddress */
+export interface AddressModel {
+    city?: string;
+    complement?: string;
+    country?: Country;
+    county?: string;
+    id?: string;
+    neighborhood?: string;
+    number?: string;
+    province?: string;
+    state?: string;
+    street?: string;
+    town?: string;
+    zipCode?: string;
+}

package/types/api.ts

@@ -0,0 +1,28 @@
+export type APISearchFilters = {
+    /**
+     * ID or UUID
+     */
+    i?: string;
+
+    /**
+     * Resource type, either:
+     *      option: to be used in select components, bare minimum data
+     *      full: to be used anywhere else, contains all the entity data
+     */
+    r?: "option" | "full";
+
+    /**
+     * Search query
+     */
+    t?: string;
+
+    /**
+     * Page number
+     */
+    page?: number | string;
+
+    /**
+     * Amount of items per page
+     */
+    perPage?: number | string;
+};

package/types/common.ts

@@ -0,0 +1,5 @@
+export type KeysMatching<T, V> = {
+    [K in keyof T]-?: T[K] extends V ? K : never;
+}[keyof T];
+
+export type Maybe<T> = NonNullable<T> | undefined;

package/types/form.ts

@@ -0,0 +1,144 @@
+import { Icon } from "@/enums/ui";
+import { Website } from "@/types/website";
+import { Pagination } from "@/types/ui";
+import { APISearchFilters } from "@/types/api";
+import { AddressModel, Country } from "@/types/address";
+import { FormDataTypes, FormSubmissionFormat } from "@/enums/form";
+
+export type SelectValuePrimitives = string | number;
+
+export type SelectValue = SelectValuePrimitives | Array<SelectValuePrimitives>;
+
+export type SelectOption = {
+    /** Optional icon, to be appended to the label */
+    icon?: `${Icon}`;
+
+    /** Option label, either a string or an object containing the props necessary to render the option */
+    label: any;
+
+    /** Optional type, used to diferentiate options from one another */
+    type?: string;
+
+    /** Optional renderer, containing the fully resolved path to the component that will be used
+     * to render the option
+     */
+    renderer?: string;
+} & (
+    | {
+          /** If true, the option is a group label and can't be selected */
+          isGroupLabel: boolean;
+
+          value?: never;
+          action?: never;
+      }
+    | {
+          /** Option value */
+          value: SelectValue;
+
+          action?: never;
+          isGroupLabel?: never;
+      }
+    | {
+          /** Action to be executed once the option is selected */
+          action: (
+              filters?: APISearchFilters,
+          ) =>
+              | Promise<{ items: unknown[]; pagination: Pagination }>
+              | Promise<void>
+              | void;
+
+          value?: never;
+          isGroupLabel?: never;
+      }
+);
+
+export interface InputSocialModel {
+    profile: string;
+    network: number;
+}
+
+export interface InputPriceModel {
+    iso: string;
+    value: number;
+}
+
+export interface InputPasswordModel {
+    value: string;
+    strength?: number;
+    updatedAt?: Date;
+
+    /** If true, encrypts the password before posting to the API */
+    encrypt?: boolean;
+}
+
+export type FormStyle = { [key in "label" | "input"]?: string };
+
+export type FormSchemaValueMap = {
+    [FormDataTypes.Address]: AddressModel;
+    [FormDataTypes.Boolean]: boolean;
+    [FormDataTypes.Country]: Country;
+    [FormDataTypes.Date]: Date;
+    [FormDataTypes.DateRange]: [Date, Date];
+    [FormDataTypes.Document]: File;
+    [FormDataTypes.Documents]: File[];
+    [FormDataTypes.Number]: number;
+    [FormDataTypes.Password]: InputPasswordModel;
+    [FormDataTypes.Price]: InputPriceModel;
+    [FormDataTypes.String]: string;
+    [FormDataTypes.StringArray]: string[];
+    [FormDataTypes.Website]: Website;
+};
+
+/**
+ * Form in the JSON format
+ */
+export type JSONForm = { [prop: string]: string | number | boolean | string[] };
+
+/**
+ * Form in the FormData format
+ */
+export type FormDataForm = InstanceType<typeof FormData>;
+
+export type FormSubmissionFormatMap = {
+    [FormSubmissionFormat.FormData]: FormDataForm;
+    [FormSubmissionFormat.JSON]: JSONForm;
+};
+
+/**
+ * Transformed form, the result of the form transformation from the high level form values
+ * to the desired submission format, either FormData or JSON
+ */
+export type TransformedForm<T = FormSubmissionFormat.FormData> =
+    T extends FormSubmissionFormat.FormData
+        ? FormDataForm
+        : T extends FormSubmissionFormat.JSON
+          ? JSONForm
+          : never;
+
+/**
+ * Validation result object, containing the validation status and the transformed form
+ */
+export type ValidationResult<T = FormSubmissionFormat.FormData> = {
+    isValid: boolean;
+    form: TransformedForm<T>;
+};
+
+/**
+ * Form schema, defining the form fields and their corresponding FormDataTypes
+ */
+export type FormSchema = {
+    [key: string]: FormDataTypes;
+};
+
+/**
+ * Object containing the form values, each value being of one of the types from
+ * FormDataTypes, defined by each corresponding input component
+ */
+export type FormInstance<T extends Record<string, FormDataTypes>> = {
+    [K in keyof T]: FormSchemaValueMap[T[K]];
+};
+
+/**
+ * Type union of the accepted values by the FormData
+ */
+export type AcceptedFormDataValues = string | Blob;

package/types/index.ts

@@ -0,0 +1,5 @@
+export * from "./address";
+export * from "./api";
+export * from "./form";
+export * from "./ui";
+export * from "./website";

package/types/ui.ts

@@ -0,0 +1,55 @@
+import { ElementPosition, ElementVariant } from "@/enums/ui";
+
+export interface Pagination {
+    /** Amount of items in current page */
+    items: number;
+
+    /** Current page */
+    page: number;
+
+    /** Amount of pages */
+    pages: number;
+
+    /** Amount of items per page */
+    perPage: number;
+
+    /** Amount of items being skipped */
+    skip: number;
+
+    /** Total number of items */
+    totalItems: number;
+}
+
+export type TableColumn = {
+    title?: string;
+} & ({ slot: string } | { property: string });
+
+export type TableEditorColumn = {
+    title?: string;
+
+    /** Property name, defaults to slot name */
+    property?: string;
+
+    /** Input type for editing column */
+    type?: "text" | "select" | "price";
+
+    /** Show/Hide column */
+    visible?: boolean;
+} & ({ slot: string } | { property: string });
+
+export type TableEditorRow = {
+    uuid: string;
+    [prop: string]: any;
+};
+
+export type Tab = {
+    title?: string;
+    slot?: string;
+};
+
+export type Message = {
+    id: number;
+    message: string;
+    variant: `${ElementVariant}`;
+    position: `${ElementPosition}`;
+};

package/types/website.ts

@@ -0,0 +1,16 @@
+export type Website = {
+    url: string;
+    uri?: string;
+    www?: boolean;
+    secureHttp?: boolean;
+    title?: string;
+    updatedAt?: string;
+    favicon?: string;
+    faviconCache?: string;
+    faviconLink?: string;
+};
+
+export type WebsiteMinified = {
+    f: string;
+    u: string;
+};