rimecms 0.22.0

package/dist/util/array.js

@@ -0,0 +1,16 @@
+/**
+ * Moves an item from one position to another within an array.
+ * Creates a new array instead of modifying the original.
+ *
+ * @example
+ * // Move the second item to the fourth position
+ * const newArray = moveItem(['a', 'b', 'c', 'd', 'e'], 1, 3);
+ * // Result: ['a', 'c', 'd', 'b', 'e']
+ */
+export const moveItem = (arr, fromIndex, toIndex) => {
+    const copy = [...arr];
+    const element = copy[fromIndex];
+    copy.splice(fromIndex, 1);
+    copy.splice(toIndex, 0, element);
+    return copy;
+};

package/dist/util/cases.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns an object with the first matching key and all keys for reference
+ * @example
+ * const auth = cases({
+ *   IS_STAFF: user.role === 'staff',
+ *   IS_ADMIN: user.role === 'admin'
+ * });
+ *
+ * switch (auth.value) {
+ *   case auth.IS_STAFF:
+ *     // Type-safe access
+ * }
+ */
+export declare const cases: <T extends Record<string, boolean>>(map: T) => {
+    value: ExtractTrueKeys<T> extends never ? (keyof T | undefined) : keyof T;
+} & { [K in keyof T]: K; };
+type ExtractTrueKeys<T> = {
+    [K in keyof T]: T[K] extends true ? K : never;
+}[keyof T];
+/**
+ * Executes the action associated with the given key
+ * @example
+ * const time = cases({
+ *   morning: config.isMorning,
+ *   afternoon: config.isAfterNoon,
+ *   night: true // default case
+ * });
+ *
+ * const whatToDo = when(time.value, {
+ *   morning: takeCoffee(),
+ *   afternoon: doRunning(),
+ *   night: takeAdring(),
+ *   default: 'code'
+ * });
+ */
+export declare const when: <K extends string | number | symbol, V>(key: K | "default", actions: Record<string, V> & {
+    default?: V;
+}) => V;
+export {};

package/dist/util/cases.js

@@ -0,0 +1,58 @@
+/**
+ * Returns an object with the first matching key and all keys for reference
+ * @example
+ * const auth = cases({
+ *   IS_STAFF: user.role === 'staff',
+ *   IS_ADMIN: user.role === 'admin'
+ * });
+ *
+ * switch (auth.value) {
+ *   case auth.IS_STAFF:
+ *     // Type-safe access
+ * }
+ */
+export const cases = (map) => {
+    // Find the first matching key
+    let value;
+    for (const [key, condition] of Object.entries(map)) {
+        if (condition) {
+            value = key;
+            break;
+        }
+    }
+    // Create the result object with value and all keys
+    const result = { value };
+    // Add each key as a property
+    for (const key of Object.keys(map)) {
+        result[key] = key;
+    }
+    return result;
+};
+/**
+ * Executes the action associated with the given key
+ * @example
+ * const time = cases({
+ *   morning: config.isMorning,
+ *   afternoon: config.isAfterNoon,
+ *   night: true // default case
+ * });
+ *
+ * const whatToDo = when(time.value, {
+ *   morning: takeCoffee(),
+ *   afternoon: doRunning(),
+ *   night: takeAdring(),
+ *   default: 'code'
+ * });
+ */
+export const when = (key, actions) => {
+    // If the key exists in actions, return that value
+    if (key in actions) {
+        return actions[key];
+    }
+    // Otherwise return the default value if it exists
+    if ('default' in actions) {
+        return actions.default;
+    }
+    // If no match and no default, return undefined
+    return undefined;
+};

package/dist/util/doc.d.ts

@@ -0,0 +1,39 @@
+import type { GenericDoc } from '../core/types/doc.js';
+import type { BuiltArea, BuiltCollection } from '../types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/**
+ * Creates a blank document based on a collection or area configuration.
+ * Initializes all fields with appropriate default values based on their type.
+ *
+ * @returns A new blank document with default values for all fields
+ *
+ * @example
+ * // Create a blank document for the 'pages' collection
+ * const blankPage = createBlankDocument(config.getCollection('pages'));
+ */
+export declare const createBlankDocument: <C extends BuiltCollection | BuiltArea, T extends GenericDoc = GenericDoc>(config: C, event?: RequestEvent) => T;
+/**
+ * Converts a flat array of documents into a nested tree structure based on parent-child relationships.
+ * Documents are organized hierarchically with each document containing its children in the _children property.
+ *
+ * @param documents - Array of documents with parent properties indicating their relationships
+ * @returns A nested tree structure where each document contains its children
+ *
+ * @example
+ * // Convert a flat list of pages into a hierarchical structure
+ * const pageTree = toNestedStructure(pagesList);
+ * // Result: [{ id: '1', _children: [{ id: '2', _children: [] }] }]
+ */
+/**
+ * Converts a flat array of documents into a nested tree structure
+ * based on _parent and _position fields
+ */
+export declare const toNestedStructure: (documents: GenericDoc[]) => GenericDoc[];
+/**
+ * Remove block type in path
+ * @example
+ * normalizePath('foo.bar.0:content.baz')
+ *
+ * // return foo.bar.0.baz
+ */
+export declare const normalizeFieldPath: (path: string) => string;

package/dist/util/doc.js

@@ -0,0 +1,128 @@
+import { isUploadConfig } from '../core/collections/upload/util/config.js';
+import { TabsBuilder } from '../fields/tabs/index.js';
+import { snapshot } from './state.js';
+/**
+ * Creates a blank document based on a collection or area configuration.
+ * Initializes all fields with appropriate default values based on their type.
+ *
+ * @returns A new blank document with default values for all fields
+ *
+ * @example
+ * // Create a blank document for the 'pages' collection
+ * const blankPage = createBlankDocument(config.getCollection('pages'));
+ */
+export const createBlankDocument = (config, event) => {
+    /**
+     * Recursively processes field definitions to create a blank document structure.
+     * Handles special field types like tabs, blocks, relations, and nested fields.
+     */
+    function reduceFieldsToBlankDocument(prev, curr) {
+        try {
+            if (curr instanceof TabsBuilder) {
+                curr.raw.tabs.forEach((tab) => {
+                    prev[tab.name] = tab.raw.fields.reduce(reduceFieldsToBlankDocument, {});
+                });
+            }
+            else if (['blocks', 'relation', 'tree'].includes(curr.type)) {
+                prev[curr.raw.name] = [];
+            }
+            else if ('fields' in curr.raw) {
+                prev[curr.raw.name] = curr.raw.fields.reduce(reduceFieldsToBlankDocument, {});
+            }
+            else {
+                if (curr.raw.defaultValue !== undefined) {
+                    if (typeof curr.raw.defaultValue === 'function') {
+                        prev[curr.raw.name] = curr.raw.defaultValue({ event });
+                    }
+                    else {
+                        prev[curr.raw.name] = curr.raw.defaultValue;
+                    }
+                }
+                else {
+                    prev[curr.raw.name] = null;
+                }
+            }
+        }
+        catch (err) {
+            console.error(curr);
+            throw err;
+        }
+        return prev;
+    }
+    const fields = config.fields.reduce(reduceFieldsToBlankDocument, {});
+    const empty = {
+        ...fields,
+        _type: config.slug,
+        _prototype: config.type
+    };
+    if (config.type === 'collection' &&
+        isUploadConfig(config) &&
+        'imageSizes' in config &&
+        config.imageSizes) {
+        empty.sizes = {};
+    }
+    return empty;
+};
+/**
+ * Converts a flat array of documents into a nested tree structure based on parent-child relationships.
+ * Documents are organized hierarchically with each document containing its children in the _children property.
+ *
+ * @param documents - Array of documents with parent properties indicating their relationships
+ * @returns A nested tree structure where each document contains its children
+ *
+ * @example
+ * // Convert a flat list of pages into a hierarchical structure
+ * const pageTree = toNestedStructure(pagesList);
+ * // Result: [{ id: '1', _children: [{ id: '2', _children: [] }] }]
+ */
+/**
+ * Converts a flat array of documents into a nested tree structure
+ * based on _parent and _position fields
+ */
+export const toNestedStructure = (documents) => {
+    const incomingDocs = snapshot(documents);
+    // Create a map for quick document lookup by ID
+    const docById = new Map();
+    incomingDocs.forEach((doc) => docById.set(doc.id, doc));
+    // Track processed documents to prevent infinite recursion
+    const processed = new Set();
+    // Process documents recursively
+    const processDocument = (doc) => {
+        if (!doc || processed.has(doc.id)) {
+            return doc;
+        }
+        processed.add(doc.id);
+        const result = { ...doc };
+        // Process children first (depth-first)
+        if (Array.isArray(result._children)) {
+            result._children = result._children
+                .map((id) => {
+                const childDoc = docById.get(id);
+                return childDoc ? processDocument(childDoc) : null;
+            })
+                .filter(Boolean);
+        }
+        // Only set the parent ID, don't process it recursively
+        if (result._parent && typeof result._parent === 'string') {
+            result._parent = docById.get(result._parent)?.id || null;
+        }
+        return result;
+    };
+    const output = incomingDocs
+        .filter((doc) => !doc._parent)
+        .map(processDocument)
+        .sort((a, b) => (a._position || 0) - (b._position || 0));
+    // Filter to get root documents and process them
+    return output;
+};
+/**
+ * Remove block type in path
+ * @example
+ * normalizePath('foo.bar.0:content.baz')
+ *
+ * // return foo.bar.0.baz
+ */
+export const normalizeFieldPath = (path) => {
+    const regExpBlockType = /:[a-zA-Z0-9]+/g;
+    return path.replace(regExpBlockType, '');
+};

package/dist/util/file.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Converts a file size in bytes to a human-readable string format
+ * @example
+ * fileSizeToString(500) // returns "0.50KB"
+ * fileSizeToString(1500000) // returns "1.50MB"
+ */
+export declare const fileSizeToString: (size: number) => string;
+/**
+ * Normalizes a filename by slugifying the name and standardizing the extension
+ * @example
+ * normalizeFileName("My Photo.JPEG") // returns { name: "my-photo", extension: "jpg" }
+ * normalizeFileName("Document 1.PDF") // returns { name: "document-1", extension: "pdf" }
+ */
+export declare const normalizeFileName: (filename: string) => {
+    name: string;
+    extension: string;
+};
+/**
+ * Type guard to check if a value is a File object
+ */
+export declare function isFile(file: any): file is File;
+/**
+ * Splits a filename into its name and extension parts
+ * @example
+ * fileNameAndExt("document.pdf") // returns { name: "document", extension: "pdf" }
+ * fileNameAndExt("image.with.dots.jpg") // returns { name: "image.with.dots", extension: "jpg" }
+ */
+export declare const fileNameAndExt: (filename: string) => {
+    name: string;
+    extension: string;
+};

package/dist/util/file.js

@@ -0,0 +1,48 @@
+import { slugify } from './string.js';
+/**
+ * Converts a file size in bytes to a human-readable string format
+ * @example
+ * fileSizeToString(500) // returns "0.50KB"
+ * fileSizeToString(1500000) // returns "1.50MB"
+ */
+export const fileSizeToString = (size) => {
+    if (size < 1_000_000) {
+        return (size / 1_000).toFixed(2) + 'KB';
+    }
+    else {
+        return (size / 1_000_000).toFixed(2) + 'MB';
+    }
+};
+/**
+ * Normalizes a filename by slugifying the name and standardizing the extension
+ * @example
+ * normalizeFileName("My Photo.JPEG") // returns { name: "my-photo", extension: "jpg" }
+ * normalizeFileName("Document 1.PDF") // returns { name: "document-1", extension: "pdf" }
+ */
+export const normalizeFileName = (filename) => {
+    const { name, extension } = fileNameAndExt(filename);
+    const normalizedName = slugify(name);
+    const normalizedExtension = extension.toLowerCase().replace('jpeg', 'jpg');
+    return {
+        name: normalizedName,
+        extension: normalizedExtension
+    };
+};
+/**
+ * Type guard to check if a value is a File object
+ */
+export function isFile(file) {
+    return file instanceof File;
+}
+/**
+ * Splits a filename into its name and extension parts
+ * @example
+ * fileNameAndExt("document.pdf") // returns { name: "document", extension: "pdf" }
+ * fileNameAndExt("image.with.dots.jpg") // returns { name: "image.with.dots", extension: "jpg" }
+ */
+export const fileNameAndExt = (filename) => {
+    return {
+        name: filename.substring(0, filename.lastIndexOf('.')),
+        extension: filename.substring(filename.lastIndexOf('.') + 1, filename.length).toLowerCase()
+    };
+};

package/dist/util/function.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Safely executes a promise and returns a tuple containing either an error or the result.
+ * This utility helps with error handling without try/catch blocks throughout the codebase.
+ *
+ * @example
+ * // Using safe to handle API calls without try/catch
+ * const [error, data] = await trycatch(() => fetchData());
+ * if (error) {
+ *   // Handle error case
+ *   console.error(error);
+ * } else {
+ *   // Process data
+ *   processData(data);
+ * }
+ */
+export declare const trycatch: <T>(promiseOrFn: Promise<T> | (() => Promise<T>)) => Promise<[Error, never] | [never, T]>;
+/**
+ * Safely executes a synchronous function and returns a tuple containing either an error or the result.
+ * This utility helps with error handling without try/catch blocks throughout the codebase.
+ *
+ * @example
+ * // Using trycatchSync to handle synchronous operations without try/catch
+ * const [error, data] = trycatchSync(() => JSON.parse(jsonString));
+ * if (error) {
+ *   // Handle error case
+ *   console.error(error);
+ * } else {
+ *   // Process data
+ *   processData(data);
+ * }
+ */
+export declare const trycatchSync: <T>(fn: () => T) => [Error, never] | [never, T];
+/**
+ * Safely executes a fetch request and treats both network errors and HTTP error status codes as errors.
+ * Returns a tuple containing either an error or the successful response.
+ *
+ * @example
+ * // Using trycatchFetch to handle both network and HTTP errors
+ * const [error, response] = await trycatchFetch('/api/data');
+ * if (error) {
+ *   // Handle both network and HTTP errors
+ *   return console.error(error);
+ * }
+ *
+ * // Process successful response
+ * const data = await response.json();
+ *
+ */
+export declare const trycatchFetch: (input: string | URL | globalThis.Request, init?: RequestInit) => Promise<[Error, never] | [never, Response]>;

package/dist/util/function.js

@@ -0,0 +1,87 @@
+/**
+ * Safely executes a promise and returns a tuple containing either an error or the result.
+ * This utility helps with error handling without try/catch blocks throughout the codebase.
+ *
+ * @example
+ * // Using safe to handle API calls without try/catch
+ * const [error, data] = await trycatch(() => fetchData());
+ * if (error) {
+ *   // Handle error case
+ *   console.error(error);
+ * } else {
+ *   // Process data
+ *   processData(data);
+ * }
+ */
+export const trycatch = async (promiseOrFn) => {
+    try {
+        // If it's a function, execute it inside the try/catch
+        const promise = typeof promiseOrFn === 'function' ? promiseOrFn() : promiseOrFn;
+        const result = await promise;
+        return [null, result];
+    }
+    catch (error) {
+        return [error, null];
+    }
+};
+/**
+ * Safely executes a synchronous function and returns a tuple containing either an error or the result.
+ * This utility helps with error handling without try/catch blocks throughout the codebase.
+ *
+ * @example
+ * // Using trycatchSync to handle synchronous operations without try/catch
+ * const [error, data] = trycatchSync(() => JSON.parse(jsonString));
+ * if (error) {
+ *   // Handle error case
+ *   console.error(error);
+ * } else {
+ *   // Process data
+ *   processData(data);
+ * }
+ */
+export const trycatchSync = (fn) => {
+    try {
+        const result = fn();
+        return [null, result];
+    }
+    catch (error) {
+        return [error, null];
+    }
+};
+/**
+ * Safely executes a fetch request and treats both network errors and HTTP error status codes as errors.
+ * Returns a tuple containing either an error or the successful response.
+ *
+ * @example
+ * // Using trycatchFetch to handle both network and HTTP errors
+ * const [error, response] = await trycatchFetch('/api/data');
+ * if (error) {
+ *   // Handle both network and HTTP errors
+ *   return console.error(error);
+ * }
+ *
+ * // Process successful response
+ * const data = await response.json();
+ *
+ */
+export const trycatchFetch = async (input, init) => {
+    try {
+        const response = await fetch(input, init);
+        if (!response.ok) {
+            // Try to get error details from response if possible
+            try {
+                const errorData = await response.json();
+                const errorMessage = errorData.message || `HTTP error! Status: ${response.status}`;
+                return [new Error(errorMessage), null];
+            }
+            catch {
+                // If we can't parse the response as JSON, use a generic error message
+                return [new Error(`HTTP error! Status: ${response.status}`), null];
+            }
+        }
+        return [null, response];
+    }
+    catch (error) {
+        return [error, null];
+    }
+};

package/dist/util/index.d.ts

@@ -0,0 +1,10 @@
+import { access } from './access/index.js';
+import * as array from './array.js';
+import * as doc from './doc.js';
+import * as file from './file.js';
+import * as object from './object.js';
+import * as random from './random.js';
+import * as state from './state.js';
+import * as string from './string.js';
+import * as validate from './validate.js';
+export { access, array, doc, file, object, random, state, string, validate };

package/dist/util/index.js

@@ -0,0 +1,10 @@
+import { access } from './access/index.js';
+import * as array from './array.js';
+import * as doc from './doc.js';
+import * as file from './file.js';
+import * as object from './object.js';
+import * as random from './random.js';
+import * as state from './state.js';
+import * as string from './string.js';
+import * as validate from './validate.js';
+export { access, array, doc, file, object, random, state, string, validate };

package/dist/util/object.d.ts

@@ -0,0 +1,147 @@
+import type { Dic, WithRequired } from './types.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 declare const pick: <T extends object, K extends keyof T>(keys: K[], obj: T) => Pick<T, K>;
+/**
+ * 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 declare const omit: <T extends object, K extends keyof T>(keys: K[], obj: T) => Omit<T, K>;
+/**
+ * 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 declare const withoutNull: <T extends object, K extends keyof T>(obj: T) => Partial<T>;
+/**
+ * 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 declare const omitId: <T extends {
+    id?: string;
+    [k: string]: any;
+}>(obj: T) => Omit<T, "id">;
+/**
+ * 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 declare function hasProps<T extends object, U extends Array<keyof T>>(props: U, obj: T): obj is WithRequired<T, U[number]>;
+/**
+ * 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 declare function hasProp<T extends object, U extends keyof T>(prop: U, obj: T): obj is T & Required<Pick<T, U>>;
+/**
+ * Checks if a value is a Buffer object.
+ *
+ * @example
+ * // Returns true for Buffer objects
+ * isBuffer(Buffer.from('test'));
+ */
+export declare function isBuffer(obj: any): any;
+/**
+ * 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 declare function isObjectLiteral(object: any): object is Dic;
+/**
+ * Options for the flattenWithGuard function
+ */
+type FlattenWithGuardOptions = {
+    /** Maximum depth to flatten (undefined for unlimited) */
+    maxDepth?: number;
+    /** Whether to preserve arrays (true) or flatten them (false) */
+    safe?: boolean;
+    /** Function to determine if a key-value pair should be flattened */
+    shouldFlat?: ([key, value]: [string, any]) => boolean;
+};
+type FlattenWithGuard = (data: Dic, opts?: FlattenWithGuardOptions) => Dic;
+/**
+ * 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 declare const flattenWithGuard: FlattenWithGuard;
+/**
+ * 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 declare const getValueAtPath: <T>(path: string, obj: Dic) => T | undefined;
+/**
+ * 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 declare const setValueAtPath: <T extends Dic>(path: string, obj: T, value: unknown) => T;
+/**
+ * Deletes a value at a specified path in an object.
+ *
+ * @example
+ * // Returns { user: { name: "John" } }
+ * deleteValueAtPath({ user: { name: "John", age: 30 } }, 'user.age');
+ */
+export declare function deleteValueAtPath<T>(obj: T, path: string): T;
+/**
+ * Check whether two object have the same structure
+ */
+export declare function matchStructure(source?: Dic, target?: Dic): boolean;
+export {};