clear-af.js 1.0.2 → 1.0.3

package/src/object_manipulation.ts

@@ -1,42 +0,0 @@
-/**
- * Create a deep clone of any object or array
- * @category Object Manipulation
- * @function deepClone
- * @param obj - The object or array to clone
- * @returns A deep clone of the object
- * @example
- * const user = { name: "Alice", skills: ["JS", "TS"] };
- * const clone = deepClone(user);
- * clone.name = "Bob";
- * clone.skills[0] = "Python";
- * console.log(user.name);    // "Alice" (unchanged)
- * console.log(user.skills[0]); // "JS" (unchanged)
- */
-function deepClone<T>(obj: T): T {
-    if (obj === null || typeof obj !== "object") return obj;
-
-    if (Array.isArray(obj)) return obj.map(item => deepClone(item)) as T;
-
-    const cloned = {} as T;
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) cloned[key] = deepClone(obj[key]);
-    }
-    return cloned;
-}
-
-/**
- * Remove duplicate values from an array
- * @category Object Manipulation
- * @function noTwins
- * @param arr - The array to remove duplicates from
- * @returns {unknown[]} A new array with unique values only
- * @example
- * noTwins([1, 2, 2, 3, 3, 3]);        // [1, 2, 3]
- * noTwins(["a", "b", "a", "c"]);      // ["a", "b", "c"]
- * noTwins([1, "1", 1, "1"]);          // [1, "1"]
- */
-function noTwins(arr: unknown[]): unknown[] {
-    return Array.from(new Set(arr));
-}
-
-export {deepClone, noTwins};

package/src/transformation.ts

@@ -1,89 +0,0 @@
-import { isEmpty } from './validation';
-
-/**
- * Transform a string to camelCase format
- * @category Transformation
- * @function camelify
- * @param str - The string to transform
- * @returns {string} The string in camelCase format
- * @example
- * camelify("hello world");       // "helloWorld"
- * camelify("C'est un test");     // "cestUnTest"
- * camelify("foo bar baz");       // "fooBarBaz"
- */
-function camelify(str: string): string {
-    let camelCased: string = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toCamelify = cleaned.split(" ");
-
-        camelCased = toCamelify.map((word, index) => {
-            if (index === 0) return word.toLowerCase();
-            return word[0].toUpperCase() + word.slice(1).toLowerCase();
-        })
-            .join('');
-    }
-    return camelCased;
-}
-
-/**
- * Transform a string to kebab-case format
- * @category Transformation
- * @function kebabify
- * @param str - The string to transform
- * @returns {string} The string in kebab-case format
- * @example
- * kebabify("hello world");       // "hello-world"
- * kebabify("C'est un test");     // "ceststun-test"
- * kebabify("foo bar baz");       // "foo-bar-baz"
- */
-function kebabify(str: string): string {
-    let kebabised: string = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toKebabify = cleaned.split(" ");
-        kebabised = toKebabify.map(word => word.toLowerCase())
-            .join("-");
-    }
-    return kebabised;
-}
-
-/**
- * Transform a string to snake_case format
- * @category Transformation
- * @function snakify
- * @param str - The string to transform
- * @returns {string} The string in snake_case format
- * @example
- * snakify("hello world");        // "hello_world"
- * snakify("C'est un test");      // "ceststun_test"
- * snakify("foo bar baz");        // "foo_bar_baz"
- */
-function snakify(str: string): string {
-    let snaked: string = "";
-    if (!isEmpty(str)) {
-        let cleaned = str.replace(/[^a-zA-Z0-9\s]/g, "");
-        let toSnakify = cleaned.split(" ");
-        snaked = toSnakify.map(word => word.toLowerCase())
-            .join("_");
-    }
-    return snaked;
-}
-
-/**
- * Capitalize the first character of a string
- * @category Transformation
- * @function capitalize
- * @param str - The string to capitalize
- * @returns {string} The string with the first character in uppercase
- * @example
- * capitalize("hello");        // "Hello"
- * capitalize("hello world");  // "Hello world"
- * capitalize("");             // ""
- */
-function capitalize(str: string): string {
-    if (isEmpty(str)) return str;
-    return str[0].toUpperCase() + str.slice(1);
-}
-
-export {camelify, kebabify, snakify, capitalize};

package/src/validation.ts

@@ -1,79 +0,0 @@
-/**
- * Check if any type of variable is empty
- * @category Validation
- * @function isEmpty
- * @param value - The variable to check
- * @returns {boolean} True if the value is empty, false otherwise
- * @example
- * isEmpty("");          // true
- * isEmpty("   ");       // true
- * isEmpty(null);        // true
- * isEmpty([]);          // true
- * isEmpty({});          // true
- * isEmpty("hello");     // false
- * isEmpty([1, 2]);      // false
- */
-function isEmpty(value: unknown): boolean {
-    if (value === null || value === undefined) return true;
-    if (typeof value === "string") return value.trim().length === 0;
-    if (Array.isArray(value)) return value.length === 0;
-    if (typeof value === "object") return Object.keys(value).length === 0;
-    return false;
-}
-
-/**
- * Check if the variable is of the chosen type
- * @category Validation
- * @function isType
- * @param value - The variable to check
- * @param type - The type you want
- * @returns {boolean} True if the value is of the chosen type, false otherwise
- * @example
- * isType("hello", "string");    // true
- * isType(42, "number");         // true
- * isType([], "object");         // true
- * isType("42", "number");       // false
- */
-function isType(value: unknown, type: string): boolean {
-    return typeof value === type;
-}
-
-/**
- * Check if an email is valid
- * @category Validation
- * @function isEmail
- * @param email - The email to check
- * @returns {boolean} True if the email is valid, false otherwise
- * @example
- * isEmail("alice@example.com");      // true
- * isEmail("bob.smith@company.co.uk"); // true
- * isEmail("invalid@.com");           // false
- * isEmail("no-at-sign.com");         // false
- */
-function isEmail(email: string): boolean {
-    const regex = /^[a-zA-Z0-9._%-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
-    return regex.test(email);
-}
-
-/**
- * Check if a URL is valid
- * @category Validation
- * @function isURL
- * @param url - The URL to check
- * @returns {boolean} True if the URL is valid, false otherwise
- * @example
- * isURL("https://www.example.com");     // true
- * isURL("http://example.com/path");     // true
- * isURL("www.example.com");             // false (missing protocol)
- * isURL("not a url");                   // false
- */
-function isURL(url: string): boolean {
-    try {
-        new URL(url);
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-export {isEmpty, isType, isEmail, isURL};

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2020",
-        "module": "commonjs",
-        "lib": [
-            "ES2020",
-            "DOM"
-        ],
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "strict": true,
-        "esModuleInterop": true,
-        "skipLibCheck": true,
-        "forceConsistentCasingInFileNames": true,
-        "declaration": true,
-        "declarationMap": true
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "node_modules"
-    ]
-}