@rebasepro/common 0.0.1-canary.0

package/src/util/storage.ts

@@ -0,0 +1,144 @@
+import { ArrayProperty, EntityValues, StorageConfig, StringProperty, UploadedFileContext } from "@rebasepro/types";
+import { randomString } from "./strings";
+
+interface ResolveFilenameStringParams<M extends object> {
+    input: string | ((context: UploadedFileContext) => (Promise<string> | string));
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty,
+    file: File;
+    propertyKey: string;
+}
+
+export async function resolveStorageFilenameString<M extends object>(
+    {
+        input,
+        storage,
+        values,
+        entityId,
+        path,
+        property,
+        file,
+        propertyKey
+    }: ResolveFilenameStringParams<M>): Promise<string> {
+    let result;
+
+    if (typeof input === "function") {
+        result = await input({
+            path,
+            entityId,
+            values,
+            property,
+            file,
+            storage,
+            propertyKey
+        });
+        if (!result)
+            console.warn("Storage callback returned empty result. Using default name value")
+    } else {
+        result = replacePlaceholders({
+            file,
+            input,
+            entityId,
+            propertyKey,
+            path
+        });
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}
+
+interface ResolveStoragePathStringParams<M extends object> {
+    input: string | ((context: UploadedFileContext) => string);
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty;
+    file: File;
+    propertyKey: string;
+}
+
+export function resolveStoragePathString<M extends object>(
+    {
+        input,
+        storage,
+        values,
+        entityId,
+        path,
+        property,
+        file,
+        propertyKey
+    }: ResolveStoragePathStringParams<M>): string {
+    let result;
+    if (typeof input === "function") {
+        result = input({
+            path,
+            entityId,
+            values,
+            property,
+            file,
+            storage,
+            propertyKey
+        });
+        if (!result)
+            console.warn("Storage callback returned empty result. Using default name value")
+    } else {
+        result = replacePlaceholders({
+            file,
+            input,
+            entityId,
+            propertyKey,
+            path
+        });
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}
+
+interface Placeholders {
+    file: File;
+    input: string;
+    entityId?: string | number;
+    propertyKey: string;
+    path?: string;
+}
+
+function replacePlaceholders({
+    file,
+    input,
+    entityId,
+    propertyKey,
+    path
+}: Placeholders) {
+    const ext = file.name.split(".").pop();
+    let result = input
+        .replace("{propertyKey}", propertyKey)
+        .replace("{rand}", randomString())
+        .replace("{file}", file.name)
+        .replace("{file.type}", file.type);
+    if (entityId) {
+        result = result.replace("{entityId}", String(entityId));
+    }
+    if (path) {
+        result = result.replace("{path}", path);
+    }
+    if (ext) {
+        result = result.replace("{file.ext}", ext);
+        const name = file.name.replace(`.${ext}`, "");
+        result = result.replace("{file.name}", name)
+    }
+
+    if (!result)
+        result = randomString() + "_" + file.name;
+
+    return result;
+}

package/src/util/strings.ts

@@ -0,0 +1,84 @@
+const kebabCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toKebabCase = (str: string) => {
+    const regExpMatchArray = str.match(kebabCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("-");
+};
+
+const snakeCaseRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
+
+export const toSnakeCase = (str: string) => {
+    const regExpMatchArray = str.match(snakeCaseRegex);
+    if (!regExpMatchArray) return "";
+    return regExpMatchArray
+        .map(x => x.toLowerCase())
+        .join("_");
+};
+
+export function randomString(strLength = 5) {
+    return Math.random().toString(36).slice(2, 2 + strLength);
+}
+
+export function randomColor() {
+    return Math.floor(Math.random() * 16777215).toString(16);
+}
+
+export function slugify(text?: string, separator = "_", lowercase = true) {
+    if (!text) return "";
+    const from = "ãàáäâẽèéëêìíïîõòóöôùúüûñç·/_,:;-"
+    const to = `aaaaaeeeeeiiiiooooouuuunc${separator}${separator}${separator}${separator}${separator}${separator}${separator}`;
+
+    for (let i = 0, l = from.length; i < l; i++) {
+        text = text.replace(new RegExp(from.charAt(i), "g"), to.charAt(i));
+    }
+
+    text = text
+        .toString() // Cast to string
+        .replace(/\s+/g, separator) // Replace spaces with separator
+        .replace(/&/g, separator) // Replace & with separator
+        .replace(/[^\w\\-]+/g, "") // Remove all non-word chars
+        .replace(new RegExp("\\" + separator + "\\" + separator + "+", "g"),
+            separator) // Replace multiple separators with single one
+        .trim() // Remove whitespace from both sides of a string
+        .replace(/^\s+|\s+$/g, "");
+
+    return lowercase
+        ? text.toLowerCase() // Convert the string to lowercase letters
+        : text;
+}
+
+export function unslugify(slug?: string): string {
+    if (!slug) return "";
+    if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
+        const result = slug.replace(/[-_]/g, " ");
+        return result.replace(/\w\S*/g, function (txt) {
+            return txt.charAt(0).toUpperCase() + txt.substring(1);
+        }).trim();
+    } else {
+        return slug.trim();
+    }
+}
+
+export function prettifyIdentifier(input: string) {
+    if (!input) return "";
+
+    let text = input;
+
+    // 1. Handle camelCase and Acronyms
+    // Group 1 ($1 $2): Lowercase followed by Uppercase (e.g., imageURL -> image URL)
+    // Group 2 ($3 $4): Uppercase followed by Uppercase+lowercase (e.g., XMLParser -> XML Parser)
+    text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
+
+    // 2. Replace hyphens/underscores with spaces
+    text = text.replace(/[_-]+/g, " ");
+
+    // 3. Capitalize first letter of each word (Title Case)
+    const s = text
+        .trim()
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+    console.log("Prettified identifier:", { input,s });
+    return s;
+}