rimecms 0.22.0

package/dist/util/object.js

@@ -0,0 +1,282 @@
+import { normalizeFieldPath } from './doc.js';
+/**
+ * Creates a new object with only the specified keys from the original object.
+ *
+ * @example
+ * // Returns { name: 'John', age: 30 }
+ * pick(['name', 'age'], { name: 'John', age: 30, email: 'john@example.com' });
+ */
+export const pick = (keys, obj) => {
+    const res = {};
+    for (const key of keys) {
+        if (key in obj) {
+            res[key] = obj[key];
+        }
+    }
+    return res;
+};
+/**
+ * Creates a new object without the specified keys from the original object.
+ *
+ * @example
+ * // Returns { email: 'john@example.com' }
+ * omit(['name', 'age'], { name: 'John', age: 30, email: 'john@example.com' });
+ */
+export const omit = (keys, obj) => {
+    const res = { ...obj };
+    for (const key of keys) {
+        delete res[key];
+    }
+    return res;
+};
+/**
+ * Creates a new object with all non-null properties from the original object.
+ *
+ * @example
+ * // Returns { name: 'John', email: 'john@example.com' }
+ * withoutNull({ name: 'John', age: null, email: 'john@example.com' });
+ */
+export const withoutNull = (obj) => {
+    const res = {};
+    for (const key of Object.keys(obj)) {
+        if (obj[key] !== null) {
+            res[key] = obj[key];
+        }
+    }
+    return res;
+};
+/**
+ * Creates a new object without the 'id' property from the original object.
+ * Specialized version of omit for the common case of removing IDs.
+ *
+ * @example
+ * // Returns { name: 'John', age: 30 }
+ * omitId({ id: '123', name: 'John', age: 30 });
+ */
+export const omitId = (obj) => omit(['id'], obj);
+/**
+ * Type guard to check if an object has all the specified properties.
+ *
+ * @example
+ * // Returns true if user has both name and email properties
+ * if (hasProps(['name', 'email'], user)) {
+ *   // TypeScript knows user.name and user.email are defined
+ *   console.log(`${user.name}: ${user.email}`);
+ * }
+ */
+export function hasProps(props, obj) {
+    return props.every((prop) => obj[prop] !== undefined);
+}
+/**
+ * Type guard to check if an object has a specific property.
+ *
+ * @example
+ * // Returns true if user has an email property
+ * if (hasProp('email', user)) {
+ *   // TypeScript knows user.email is defined
+ *   sendEmail(user.email);
+ * }
+ */
+export function hasProp(prop, obj) {
+    return obj[prop] !== undefined;
+}
+/**
+ * Checks if a value is a Buffer object.
+ *
+ * @example
+ * // Returns true for Buffer objects
+ * isBuffer(Buffer.from('test'));
+ */
+export function isBuffer(obj) {
+    return (obj &&
+        obj.constructor &&
+        typeof obj.constructor.isBuffer === 'function' &&
+        obj.constructor.isBuffer(obj));
+}
+/**
+ * Checks if a value is a plain object literal (not an array, null, or a class instance).
+ *
+ * @example
+ * // Returns true
+ * isObjectLiteral({ a: 1, b: 2 });
+ *
+ * // Returns false
+ * isObjectLiteral([1, 2, 3]);
+ * isObjectLiteral(null);
+ * isObjectLiteral(new Date());
+ */
+export function isObjectLiteral(object) {
+    return (typeof object === 'object' &&
+        object !== null &&
+        !Array.isArray(object) &&
+        Object.getPrototypeOf(object) === Object.prototype);
+}
+/**
+ * Flattens a nested object structure into a single-level object with dot notation keys.
+ * Provides options to control the flattening behavior.
+ *
+ * @example
+ * // Basic usage - returns { "user.name": "John", "user.address.city": "New York" }
+ * flattenWithGuard({ user: { name: "John", address: { city: "New York" } } });
+ *
+ * // With maxDepth=1 - returns { "user.name": "John", "user.address": { city: "New York" } }
+ * flattenWithGuard({ user: { name: "John", address: { city: "New York" } } }, { maxDepth: 1 });
+ *
+ * // With shouldFlat - only flatten properties that aren't "address"
+ * // Returns { "user.name": "John", "user.address": { city: "New York" } }
+ * flattenWithGuard(
+ *   { user: { name: "John", address: { city: "New York" } } },
+ *   { shouldFlat: ([key]) => key !== "address" }
+ * );
+ */
+export const flattenWithGuard = (data, opts) => {
+    opts = opts || {};
+    const delimiter = '.';
+    const shouldFlat = opts.shouldFlat || (() => true);
+    const maxDepth = opts.maxDepth;
+    const output = {};
+    const safe = opts.safe || false;
+    function step(object, prev, currentDepth) {
+        currentDepth = currentDepth || 1;
+        Object.keys(object).forEach(function (key) {
+            const value = object[key];
+            const isarray = safe && Array.isArray(value);
+            const type = Object.prototype.toString.call(value);
+            const isbuffer = isBuffer(value);
+            const isobject = type === '[object Object]' || type === '[object Array]';
+            const newKey = prev ? prev + delimiter + key : key;
+            if (shouldFlat([key, value]) &&
+                !isarray &&
+                !isbuffer &&
+                isobject &&
+                Object.keys(value).length &&
+                (!maxDepth || currentDepth < maxDepth)) {
+                return step(value, newKey, currentDepth + 1);
+            }
+            output[newKey] = value;
+        });
+    }
+    step(data);
+    return output;
+};
+/**
+ * Gets a value from a nested object using a dot notation path.
+ *
+ * @example
+ * // Returns "New York"
+ * getValueAtPath('user.address.city', { user: { address: { city: "New York" } } });
+ *
+ * // Returns undefined
+ * getValueAtPath('user.phone', { user: { address: { city: "New York" } } });
+ */
+export const getValueAtPath = (path, obj) => {
+    path = normalizeFieldPath(path);
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (/^d+$/.test(part)) {
+            current = current[parseInt(part)];
+        }
+        else {
+            current = current[part];
+        }
+        if (current === undefined) {
+            return undefined;
+        }
+    }
+    return current;
+};
+/**
+ * Sets a value in a nested object using a dot notation path.
+ * Creates the path if it doesn't exist and returns a new object without modifying the original.
+ *
+ * @example
+ * // Returns { user: { address: { city: "Boston" } } }
+ * setValueAtPath('user.address.city', { user: { address: { city: "New York" } } }, 'Boston');
+ *
+ * // Creates missing path and returns { user: { phone: "555-1234" } }
+ * setValueAtPath('user.phone', { user: {} }, '555-1234');
+ */
+export const setValueAtPath = (path, obj, value) => {
+    path = normalizeFieldPath(path);
+    const parts = path.split('.');
+    // Create a shallow copy of the root object
+    const result = { ...obj };
+    let current = result;
+    let previous = null;
+    let previousKey = '';
+    // Navigate to the parent of the target property
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const index = /^\d+$/.test(part) ? parseInt(part) : part;
+        previous = current;
+        previousKey = index;
+        // Create the object path if it doesn't exist
+        if (!current[index]) {
+            // If the next part is a number, create an array, otherwise create an object
+            const nextPart = parts[i + 1];
+            const isNextPartNumeric = /^\d+$/.test(nextPart);
+            current[index] = isNextPartNumeric ? [] : {};
+        }
+        // Create a shallow copy of the current level before moving deeper
+        if (Array.isArray(current[index])) {
+            current[index] = [...current[index]];
+        }
+        else if (typeof current[index] === 'object' && current[index] !== null) {
+            current[index] = { ...current[index] };
+        }
+        current = current[index];
+    }
+    // Set the value at the final path segment
+    const lastPart = parts[parts.length - 1];
+    const lastIndex = /^\d+$/.test(lastPart) ? parseInt(lastPart) : lastPart;
+    if (previous !== null) {
+        if (Array.isArray(previous[previousKey])) {
+            previous[previousKey][lastIndex] = value;
+        }
+        else if (typeof previous[previousKey] === 'object' && previous[previousKey] !== null) {
+            previous[previousKey][lastIndex] = value;
+        }
+    }
+    else {
+        // Use a type assertion only for the assignment
+        result[lastIndex] = value;
+    }
+    return result;
+};
+/**
+ * Deletes a value at a specified path in an object.
+ *
+ * @example
+ * // Returns { user: { name: "John" } }
+ * deleteValueAtPath({ user: { name: "John", age: 30 } }, 'user.age');
+ */
+export function deleteValueAtPath(obj, path) {
+    path = normalizeFieldPath(path);
+    const parts = path.split('.');
+    const last = parts.pop();
+    let current = obj;
+    for (const part of parts) {
+        const key = !isNaN(Number(part)) ? Number(part) : part;
+        if (!(key in current))
+            return obj;
+        current = current[key];
+    }
+    const finalKey = !isNaN(Number(last)) ? Number(last) : last;
+    delete current[finalKey];
+    return obj;
+}
+/**
+ * Check whether two object have the same structure
+ */
+export function matchStructure(source, target) {
+    if (!source || !target)
+        return false;
+    const sourceKeys = Object.keys(source);
+    const targetKeys = Object.keys(target);
+    if (sourceKeys.length !== targetKeys.length) {
+        return false;
+    }
+    const sourceSet = new Set(sourceKeys);
+    return targetKeys.every((key) => sourceSet.has(key));
+}

package/dist/util/random.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generates a random alphanumeric string of specified length.
+ * Useful for creating unique identifiers, temporary tokens, or random keys.
+ *
+ * @example
+ * // Generate a random ID with 10 characters
+ * const id = randomId(10);
+ * // Result example: "a7bF9cD3eZ"
+ */
+export declare const randomId: (length: number) => string;
+/**
+ * Generate a secure random password with uppercase, lowercase, numbers and symbols
+ *
+ * @example
+ * // Generate a password with default length (12)
+ * const password = generateSecurePassword();
+ *
+ * // Generate a password with custom length
+ * const longPassword = generateSecurePassword(16);
+ */
+export declare const randomPassword: (length?: number) => string;

package/dist/util/random.js

@@ -0,0 +1,98 @@
+/**
+ * Generates a random alphanumeric string of specified length.
+ * Useful for creating unique identifiers, temporary tokens, or random keys.
+ *
+ * @example
+ * // Generate a random ID with 10 characters
+ * const id = randomId(10);
+ * // Result example: "a7bF9cD3eZ"
+ */
+export const randomId = (length) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    let result = '';
+    const randomValues = new Uint32Array(length);
+    // Use crypto.getRandomValues for better randomness when available
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        crypto.getRandomValues(randomValues);
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(randomValues[i] % charactersLength);
+        }
+    }
+    else {
+        // Fallback to Math.random
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+    }
+    return result;
+};
+/**
+ * Generate a secure random password with uppercase, lowercase, numbers and symbols
+ *
+ * @example
+ * // Generate a password with default length (12)
+ * const password = generateSecurePassword();
+ *
+ * // Generate a password with custom length
+ * const longPassword = generateSecurePassword(16);
+ */
+export const randomPassword = (length = 12) => {
+    const uppercaseChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const lowercaseChars = 'abcdefghijklmnopqrstuvwxyz';
+    const numberChars = '0123456789';
+    const symbolChars = '!@#$%^&*()_-+=[]{}|:;<>,.?/~';
+    // All possible characters
+    const allChars = uppercaseChars + lowercaseChars + numberChars + symbolChars;
+    let password = '';
+    // Use crypto.getRandomValues for better randomness when available
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+        // Ensure we have at least one character from each character set
+        const randomValues = new Uint32Array(length);
+        crypto.getRandomValues(randomValues);
+        // First add one character from each required set
+        password += uppercaseChars.charAt(randomValues[0] % uppercaseChars.length);
+        password += lowercaseChars.charAt(randomValues[1] % lowercaseChars.length);
+        password += numberChars.charAt(randomValues[2] % numberChars.length);
+        password += symbolChars.charAt(randomValues[3] % symbolChars.length);
+        // Fill the rest with random characters
+        for (let i = 4; i < length; i++) {
+            password += allChars.charAt(randomValues[i] % allChars.length);
+        }
+        // Shuffle the password
+        const shuffleValues = new Uint32Array(length);
+        crypto.getRandomValues(shuffleValues);
+        password = shuffleString(password, shuffleValues);
+    }
+    else {
+        // Fallback to Math.random
+        password += uppercaseChars.charAt(Math.floor(Math.random() * uppercaseChars.length));
+        password += lowercaseChars.charAt(Math.floor(Math.random() * lowercaseChars.length));
+        password += numberChars.charAt(Math.floor(Math.random() * numberChars.length));
+        password += symbolChars.charAt(Math.floor(Math.random() * symbolChars.length));
+        // Fill the rest with random characters
+        for (let i = 4; i < length; i++) {
+            password += allChars.charAt(Math.floor(Math.random() * allChars.length));
+        }
+        // Shuffle the password
+        password = shuffleString(password);
+    }
+    return password;
+};
+/**
+ * Shuffle a string using Fisher-Yates algorithm
+ */
+const shuffleString = (str, randomValues) => {
+    const array = str.split('');
+    for (let i = array.length - 1; i > 0; i--) {
+        let j;
+        if (randomValues && i < randomValues.length) {
+            j = randomValues[i] % (i + 1);
+        }
+        else {
+            j = Math.floor(Math.random() * (i + 1));
+        }
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array.join('');
+};

package/dist/util/state.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a deep copy of a state object, removing any proxies or reactive wrappers.
+ * Useful for getting a clean snapshot of reactive state that can be serialized or compared.
+ *
+ * @example
+ * // Get a clean snapshot of a reactive state object
+ * const reactiveState = { count: 1, nested: { value: 'test' } };
+ * const cleanCopy = snapshot(reactiveState);
+ * // cleanCopy can now be safely serialized or compared
+ */
+export declare const snapshot: <T>(state: T) => T;

package/dist/util/state.js

@@ -0,0 +1,50 @@
+/**
+ * Creates a deep copy of a state object, removing any proxies or reactive wrappers.
+ * Useful for getting a clean snapshot of reactive state that can be serialized or compared.
+ *
+ * @example
+ * // Get a clean snapshot of a reactive state object
+ * const reactiveState = { count: 1, nested: { value: 'test' } };
+ * const cleanCopy = snapshot(reactiveState);
+ * // cleanCopy can now be safely serialized or compared
+ */
+export const snapshot = (state) => {
+    // Unwraps a proxy object to get its target value
+    function unProxy(object) {
+        if (object && object.constructor === Proxy) {
+            return object.target;
+        }
+        return object;
+    }
+    // Processes each item in an array recursively
+    function parseArray(array) {
+        const ouput = [];
+        for (const [index, item] of array.entries()) {
+            ouput[index] = step(item);
+        }
+        return ouput;
+    }
+    // Processes each property in an object recursively
+    function parseObject(object) {
+        const output = {};
+        for (const [key, value] of Object.entries(object)) {
+            output[key] = step(value);
+        }
+        return output;
+    }
+    // Recursively processes a value based on its type
+    function step(object) {
+        const isArray = Array.isArray(object);
+        const type = Object.prototype.toString.call(object);
+        const isObject = type === '[object Object]';
+        let output = unProxy(object);
+        if (isArray) {
+            output = parseArray(object);
+        }
+        if (isObject) {
+            output = parseObject(object);
+        }
+        return output;
+    }
+    return step(state);
+};

package/dist/util/string.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @example
+ * // Returns "Hello"
+ * capitalize("hello");
+ */
+export declare const capitalize: (str: string) => string;
+/**
+ * Converts a string to camelCase.
+ * Uses the camelcase package for consistent conversion.
+ *
+ * @example
+ * // Returns "helloWorld"
+ * toCamelCase("hello-world");
+ */
+export declare const toCamelCase: (str: string) => string;
+export declare function toKebabCase(str: string): string;
+/**
+ * Converts a string to PascalCase.
+ * Uses the camelcase package with pascalCase option.
+ *
+ * @example
+ * // Returns "HelloWorld"
+ * toPascalCase("hello-world");
+ */
+export declare const toPascalCase: (str: string) => string;
+/**
+ * Converts a string to snake_case.
+ * This is a custom implementation that replaces the to-snake-case dependency
+ * and maintains the same functionality of the original package.
+ *
+ * @example
+ * // Returns "hello_world"
+ * toSnakeCase("helloWorld");
+ *
+ * // Returns "_hello_world"
+ * toSnakeCase("_helloWorld");
+ */
+export declare const toSnakeCase: (str: string) => string;
+/**
+ * Converts a string to a URL-friendly slug.
+ * Handles special characters, spaces, and Unicode normalization.
+ *
+ * @example
+ * // Returns "hello-world"
+ * slugify("Hello World!");
+ *
+ * // Returns "accentue"
+ * slugify("Accentué");
+ */
+export declare const slugify: (text: string) => string;
+/**
+ * Generates a numeric hash from a string using a simple hashing algorithm.
+ * Useful for generating deterministic IDs from string content.
+ *
+ * @example
+ * // Returns a consistent numeric hash string
+ * toHash("hello");
+ */
+export declare function toHash(str: string): string;
+/**
+ * Checks if a string is in camelCase format.
+ * Validates that the string starts with a lowercase letter and contains only letters and numbers.
+ *
+ * @example
+ * // Returns true
+ * isCamelCase("helloWorld");
+ *
+ * // Returns false
+ * isCamelCase("HelloWorld");
+ *
+ * // Returns false
+ * isCamelCase("hello_world");
+ */
+export declare const isCamelCase: (str: string) => boolean;
+/**
+ * Validates if a string is a valid slug format.
+ * Must start with a letter, contain only letters, numbers, hyphens, and underscores.
+ *
+ * @example
+ * // Returns true
+ * isValidSlug("hello-world");
+ *
+ * // Returns true
+ * isValidSlug("user_profile");
+ *
+ * // Returns false
+ * isValidSlug("123invalid");
+ *
+ * // Returns false
+ * isValidSlug("hello world");
+ */
+export declare const isValidSlug: (str: string) => boolean;