rimecms 0.33.0 → 1.0.0

package/dist/panel/util/upload-file.js

@@ -0,0 +1,165 @@
+import { PARAMS } from '../../core/constants.js';
+import { getExtensionFromMimeType } from '../../core/prototype/collection/upload/util/mime.js';
+import { trycatchFetch } from '../../util/function.js';
+/**
+ * Whether the collection takes this file. No `accept` takes anything.
+ *
+ * ```ts
+ * isAccepted(photo, ['image/jpeg', 'image/png']) // true for a .jpg
+ * ```
+ */
+export const isAccepted = (file, accept) => !accept?.length || accept.includes(file.type);
+/**
+ * A mime type as people read it.
+ *
+ * ```ts
+ * typeLabel('image/jpeg')      // 'JPG'
+ * typeLabel('application/pdf') // 'PDF'
+ * ```
+ */
+export const typeLabel = (mimeType) => {
+    if (!mimeType)
+        return '';
+    return (getExtensionFromMimeType(mimeType) ?? mimeType.split('/').pop() ?? '').toUpperCase();
+};
+const BYTES = { B: 1, KB: 1_000, MB: 1_000_000, GB: 1_000_000_000 };
+/**
+ * A file size in bytes, from a count of bytes or a stored size.
+ *
+ * ```ts
+ * fileSizeBytes('3.20MB') // 3200000
+ * fileSizeBytes('0.84KB') // 840
+ * fileSizeBytes(840)      // 840
+ * fileSizeBytes('')       // null
+ * ```
+ */
+export const fileSizeBytes = (size) => {
+    if (typeof size === 'number')
+        return Number.isFinite(size) ? size : null;
+    const match = size?.trim().match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+    if (!match)
+        return null;
+    const unit = (match[2]?.toUpperCase() ?? 'B');
+    return Math.round(parseFloat(match[1]) * BYTES[unit]);
+};
+/**
+ * A file size as people read it: whole kilobytes, then one decimal from a megabyte up.
+ *
+ * ```ts
+ * fileSizeLabel('3.20MB')      // '3.2 MB'
+ * fileSizeLabel('840.12KB')    // '840 KB'
+ * fileSizeLabel(1_240_000_000) // '1.2 GB'
+ * fileSizeLabel(512)           // '512 B'
+ * ```
+ */
+export const fileSizeLabel = (size) => {
+    const bytes = fileSizeBytes(size);
+    if (bytes === null)
+        return '';
+    if (bytes < BYTES.KB)
+        return `${bytes} B`;
+    const kilobytes = Math.round(bytes / BYTES.KB);
+    if (kilobytes < 1000)
+        return `${kilobytes} KB`;
+    const megabytes = bytes / BYTES.MB;
+    if (megabytes < 999.95)
+        return `${megabytes.toFixed(1)} MB`;
+    return `${(bytes / BYTES.GB).toFixed(1)} GB`;
+};
+/**
+ * A media's size and type, for the line under its name.
+ *
+ * ```ts
+ * mediaMeta({ filesize: '3.20MB', mimeType: 'image/jpeg' }) // '3.2 MB · JPG'
+ * ```
+ */
+export const mediaMeta = (doc) => [fileSizeLabel(doc.filesize), typeLabel(doc.mimeType ?? undefined)].filter(Boolean).join(' · ');
+export const MEDIA_KINDS = ['image', 'video', 'audio', 'document', 'other'];
+const DOCUMENT_TYPES = /^(text\/|application\/(pdf|rtf|msword|vnd\.ms-|vnd\.openxmlformats-officedocument|vnd\.oasis\.opendocument))/;
+/**
+ * The kind of file a mime type is, to filter medias by.
+ *
+ * ```ts
+ * mediaKind('image/webp')      // 'image'
+ * mediaKind('application/pdf') // 'document'
+ * mediaKind('application/zip') // 'other'
+ * ```
+ */
+export const mediaKind = (mimeType) => {
+    const type = mimeType ?? '';
+    if (type.startsWith('image/'))
+        return 'image';
+    if (type.startsWith('video/'))
+        return 'video';
+    if (type.startsWith('audio/'))
+        return 'audio';
+    if (DOCUMENT_TYPES.test(type))
+        return 'document';
+    return 'other';
+};
+/**
+ * The accepted types as a sentence.
+ *
+ * ```ts
+ * acceptLabel(['image/jpeg', 'image/png', 'image/webp'], 'or') // 'JPG, PNG or WEBP'
+ * ```
+ */
+export const acceptLabel = (accept, or) => {
+    const labels = [...new Set(accept.map(typeLabel))];
+    if (labels.length < 2)
+        return labels.join('');
+    return `${labels.slice(0, -1).join(', ')} ${or} ${labels.at(-1)}`;
+};
+const readAsDataURL = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => typeof reader.result === 'string'
+        ? resolve(reader.result)
+        : reject(new Error(`Cannot read ${file.name}`));
+    reader.onerror = () => reject(reader.error ?? new Error(`Cannot read ${file.name}`));
+    reader.readAsDataURL(file);
+});
+/**
+ * Creates one document of an upload collection from a file, and answers it.
+ * Validation is skipped, so a required field the file cannot fill, like an `alt`, never blocks it.
+ *
+ * ```ts
+ * const doc = await uploadFile(file, { url: '/api/medias', path: 'root:press' });
+ * ```
+ */
+export async function uploadFile(file, target) {
+    if (!isAccepted(file, target.accept)) {
+        throw new Error(`${file.name} is not of an accepted type`);
+    }
+    const base64 = await readAsDataURL(file);
+    const [error, response] = await trycatchFetch(`${target.url}?${PARAMS.SKIP_VALIDATION}=true`, {
+        method: 'POST',
+        body: JSON.stringify({ _path: target.path, file: { base64, filename: file.name } })
+    });
+    if (error)
+        throw error;
+    const { doc } = await response.json();
+    return doc;
+}
+/**
+ * Uploads files one after the other. A file that fails is counted and skipped.
+ *
+ * ```ts
+ * const { docs, failed } = await uploadFiles(files, target, (progress) => (state = progress));
+ * ```
+ */
+export async function uploadFiles(files, target, onProgress) {
+    const docs = [];
+    const failed = [];
+    const report = (current) => onProgress?.({ total: files.length, uploaded: docs.length, failed: [...failed], current });
+    for (const file of files) {
+        report(file.name);
+        try {
+            docs.push(await uploadFile(file, target));
+        }
+        catch {
+            failed.push(file.name);
+        }
+    }
+    report(null);
+    return { docs, failed };
+}

package/dist/util/index.d.ts

@@ -12,14 +12,11 @@ import * as string from './string.js';
  *
  * This is a **barrel, not a home**: what a namespace here re-exports and where that code lives
  * are separate questions. Everything in `./*` passes the util rule (no rime vocabulary), while
- * `access`, `validate` and half of `doc` name rime types and therefore live with their concept
- * — auth, fields and prototype respectively. They are published from here because that is the
- * path config authors import them from.
+ * `access` and `validate` name rime types and therefore live with their concept — auth and fields
+ * respectively. They are published from here because that is the path config authors import them
+ * from.
+ *
+ * Nothing inside the library imports from here: internal code reaches for the module itself, so
+ * this barrel stays a leaf of the import graph.
  */
-/** `doc`'s two halves, each living with the concept it names. */
-declare const doc: {
-    normalizeFieldPath: (path: string) => string;
-    createBlankDocument: <C extends import("../types.js").BuiltCollection | import("../types.js").BuiltArea, T extends import("../core/prototype/types.js").GenericDoc = import("../core/prototype/types.js").GenericDoc>(config: C, event?: import("@sveltejs/kit").RequestEvent) => T;
-    toNestedStructure: (documents: import("../core/prototype/types.js").GenericDoc[]) => import("../core/prototype/types.js").GenericDoc[];
-};
-export { access, array, doc, file, object, random, state, string, upload, validate };
+export { access, array, file, object, random, state, string, upload, validate };

package/dist/util/index.js

@@ -1,11 +1,9 @@
 import { access } from '../core/auth/access.js';
 import * as validate from '../core/fields/validate.js';
 import * as upload from '../core/prototype/collection/upload/util/client.js';
-import * as docBuilders from '../core/prototype/doc.js';
 import * as array from './array.js';
 import * as file from './file.js';
 import * as object from './object.js';
-import * as docPath from './path.js';
 import * as random from './random.js';
 import * as state from './state.js';
 import * as string from './string.js';
@@ -14,10 +12,11 @@ import * as string from './string.js';
  *
  * This is a **barrel, not a home**: what a namespace here re-exports and where that code lives
  * are separate questions. Everything in `./*` passes the util rule (no rime vocabulary), while
- * `access`, `validate` and half of `doc` name rime types and therefore live with their concept
- * — auth, fields and prototype respectively. They are published from here because that is the
- * path config authors import them from.
+ * `access` and `validate` name rime types and therefore live with their concept — auth and fields
+ * respectively. They are published from here because that is the path config authors import them
+ * from.
+ *
+ * Nothing inside the library imports from here: internal code reaches for the module itself, so
+ * this barrel stays a leaf of the import graph.
  */
-/** `doc`'s two halves, each living with the concept it names. */
-const doc = { ...docBuilders, ...docPath };
-export { access, array, doc, file, object, random, state, string, upload, validate };
+export { access, array, file, object, random, state, string, upload, validate };

package/dist/util/object.d.ts

@@ -35,6 +35,16 @@ export declare const omitId: <T extends {
     id?: string;
     [k: string]: any;
 }>(obj: T) => Omit<T, "id">;
+/**
+ * `obj` with every key it lacks taken from `defaults`, an object both hold merged the same way.
+ * Anything the object holds is the object's — `null` included, an array as it is.
+ *
+ * ```
+ * withDefaults({ title: 'T', seo: { og: null } }, { title: null, body: null, seo: { og: null, meta: null } })
+ * // { title: 'T', seo: { og: null, meta: null }, body: null }
+ * ```
+ */
+export declare const withDefaults: <T extends Dic>(obj: T, defaults: Dic) => T;
 /**
  * Type guard to check if an object has all the specified properties.
  *

package/dist/util/object.js

@@ -1,4 +1,4 @@
-import { normalizeFieldPath } from './path.js';
+import { normalizeFieldPath } from './string.js';
 /**
  * Creates a new object with only the specified keys from the original object.
  *
@@ -54,6 +54,27 @@ export const withoutNull = (obj) => {
  * omitId({ id: '123', name: 'John', age: 30 });
  */
 export const omitId = (obj) => omit(['id'], obj);
+/**
+ * `obj` with every key it lacks taken from `defaults`, an object both hold merged the same way.
+ * Anything the object holds is the object's — `null` included, an array as it is.
+ *
+ * ```
+ * withDefaults({ title: 'T', seo: { og: null } }, { title: null, body: null, seo: { og: null, meta: null } })
+ * // { title: 'T', seo: { og: null, meta: null }, body: null }
+ * ```
+ */
+export const withDefaults = (obj, defaults) => {
+    const out = { ...obj };
+    for (const key of Object.keys(defaults)) {
+        const value = obj[key];
+        if (value === undefined)
+            out[key] = defaults[key];
+        else if (isObjectLiteral(value) && isObjectLiteral(defaults[key])) {
+            out[key] = withDefaults(value, defaults[key]);
+        }
+    }
+    return out;
+};
 /**
  * Type guard to check if an object has all the specified properties.
  *

package/dist/util/string.d.ts

@@ -128,3 +128,20 @@ export declare const isValidSlug: (str: string) => boolean;
  * allowed tags : ['strong', 'b', 'em', 'i', 'u', 'br', 'a']
  */
 export declare const sanitize: (value?: string) => string;
+/**
+ * The members of a generated type literal, one per line. A container's own type ends with a
+ * comma and a leaf's does not, so each is stripped before the join.
+ *
+ * ```ts
+ * joinMemberTypes(['title: string', 'facts: Array<TreeFacts>,']) // 'title: string,\nfacts: Array<TreeFacts>'
+ * ```
+ */
+export declare const joinMemberTypes: (types: string[]) => string;
+/**
+ * Removes the block type from a field path.
+ *
+ * ```ts
+ * normalizeFieldPath('foo.bar.0:content.baz'); // 'foo.bar.0.baz'
+ * ```
+ */
+export declare const normalizeFieldPath: (path: string) => string;

package/dist/util/string.js

@@ -301,3 +301,26 @@ export const sanitize = (value) => {
     const sanitized = root.children ? root.children.map(processNode).join('') : '';
     return decode(restoreWhitespace(sanitized));
 };
+/**
+ * The members of a generated type literal, one per line. A container's own type ends with a
+ * comma and a leaf's does not, so each is stripped before the join.
+ *
+ * ```ts
+ * joinMemberTypes(['title: string', 'facts: Array<TreeFacts>,']) // 'title: string,\nfacts: Array<TreeFacts>'
+ * ```
+ */
+export const joinMemberTypes = (types) => types
+    .map((type) => type.trim().replace(/,$/, ''))
+    .filter(Boolean)
+    .join(',\n');
+/**
+ * Removes the block type from a field path.
+ *
+ * ```ts
+ * normalizeFieldPath('foo.bar.0:content.baz'); // 'foo.bar.0.baz'
+ * ```
+ */
+export const normalizeFieldPath = (path) => {
+    const regExpBlockType = /:[a-zA-Z0-9]+/g;
+    return path.replace(regExpBlockType, '');
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimecms",
-  "version": "0.33.0",
+  "version": "1.0.0",
   "homepage": "https://github.com/bienbiendev/rime",
   "packageManager": "bun@1.3.0",
   "scripts": {
@@ -233,11 +233,9 @@
     "camelcase": "^8.0.0",
     "chalk": "^5.6.2",
     "clone-deep": "^4.0.1",
-    "command-score": "^0.1.2",
     "commander": "^12.1.0",
     "dedent": "^1.5.3",
     "deep-object-diff": "^1.1.9",
-    "deepmerge": "^4.3.1",
     "dotenv": "^16.4.7",
     "drizzle-orm": "1.0.0-rc.4",
     "flat": "^6.0.1",

package/dist/core/pipeline/config-map/build-tree-map.d.ts

@@ -1,4 +0,0 @@
-import type { TreeBlock } from '../../prototype/types.js';
-import type { TreeBuilder } from '../../../fields/tree/index.js';
-import type { ConfigMap } from './types.js';
-export declare function buildTreeFieldsMap(treeConfig: TreeBuilder, treeItems: TreeBlock[], basePath: string): ConfigMap;

package/dist/core/pipeline/config-map/build-tree-map.js

@@ -1,30 +0,0 @@
-import { isFormField } from '../../fields/util.js';
-export function buildTreeFieldsMap(treeConfig, treeItems, basePath) {
-    const treeMap = {};
-    // Helper to add field configs for a specific path
-    const addFieldConfigs = (path) => {
-        for (const field of treeConfig.get.fields) {
-            if (isFormField(field)) {
-                treeMap[`${path}.${field.name}`] = field;
-            }
-        }
-    };
-    // Process each item in the tree
-    const processItem = (item, itemPath) => {
-        // Add configs for current item
-        addFieldConfigs(itemPath);
-        // If item has children, process them
-        if (item._children && Array.isArray(item._children)) {
-            item._children.forEach((child, childIndex) => {
-                const childPath = `${itemPath}._children.${childIndex}`;
-                processItem(child, childPath);
-            });
-        }
-    };
-    // Process each root level item
-    treeItems.forEach((item, index) => {
-        const itemPath = `${basePath}.${index}`;
-        processItem(item, itemPath);
-    });
-    return treeMap;
-}

package/dist/core/prototype/doc.d.ts

@@ -1,31 +0,0 @@
-import type { GenericDoc } from './types.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[];

package/dist/core/prototype/doc.js

@@ -1,118 +0,0 @@
-import { FormFieldBuilder } from '../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../fields/group/index.js';
-import { TabsBuilder } from '../../fields/tabs/index.js';
-import { snapshot } from '../../util/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.get.tabs.forEach((tab) => {
-                    prev[tab.name] = tab.get.fields.reduce(reduceFieldsToBlankDocument, {});
-                });
-            }
-            else if (['blocks', 'relation', 'tree'].includes(curr.type)) {
-                prev[curr.name] = [];
-            }
-            else if (curr instanceof GroupFieldBuilder) {
-                prev[curr.name] = curr.get.fields.reduce(reduceFieldsToBlankDocument, {});
-            }
-            else if (curr instanceof FormFieldBuilder) {
-                // Presentational fields (separator, bare component()) are plain
-                // FieldBuilder, never FormFieldBuilder, and get skipped here rather
-                // than assigned `prev['']` (they never got a real name) — that used
-                // to corrupt the parent object into looking array-like once
-                // flattened/unflattened.
-                const defaultValue = curr.use.defaultValue({ event });
-                prev[curr.name] = defaultValue !== undefined ? defaultValue : null;
-            }
-        }
-        catch (err) {
-            console.error(curr);
-            throw err;
-        }
-        return prev;
-    }
-    const fields = config.fields.reduce(reduceFieldsToBlankDocument, {});
-    /**
-     * The fields, plus what every document has regardless of kind. Nothing feature-shaped: a
-     * feature adds to this through `FeatureDefinition.blank`, which the local API folds — see
-     * `prototype/api.server.ts`.
-     *
-     * An `isUploadConfig(config) && 'imageSizes' in config` branch used to seed `sizes: {}` here.
-     * It never once ran: `imageSizes` is a member of `UploadConfig`, so it lives at
-     * `config.upload.imageSizes` and never at `config.imageSizes` — every other reader in the repo
-     * uses the former. Removed rather than moved to `upload.blank`, because reviving a branch that
-     * has never executed is a behaviour change, not a relocation.
-     */
-    return {
-        ...fields,
-        _type: config.slug,
-        _prototype: config.type
-    };
-};
-/**
- * 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;
-};

package/dist/core/prototype/shared/url/augment.d.ts

@@ -1,13 +0,0 @@
-import type { Collection } from '../../../config/types.js';
-type Input = {
-    $url?: Collection<any>['$url'];
-    fields?: Collection<any>['fields'];
-};
-/**
- * Adds the hidden `url` field a document's computed url is stored in.
- *
- * Applied only to configs that declare `$url`, which the feature's `enabled` decides, so there is
- * no condition here. See features/url/index.ts.
- */
-export declare const augmentUrl: <T extends Input>(config: T) => T;
-export {};

package/dist/core/prototype/shared/url/augment.js

@@ -1,11 +0,0 @@
-import { text } from '../../../../fields/text/index.js';
-/**
- * Adds the hidden `url` field a document's computed url is stored in.
- *
- * Applied only to configs that declare `$url`, which the feature's `enabled` decides, so there is
- * no condition here. See features/url/index.ts.
- */
-export const augmentUrl = (config) => ({
-    ...config,
-    fields: [...(config.fields || []), text('url').localized().hidden()]
-});

package/dist/core/prototype/shared/url/hooks/populate-url.server.d.ts

@@ -1,4 +0,0 @@
-/**
- * Hook to populate _children property on document from a nested collection
- */
-export declare const populateURL: import("../../../../pipeline/types").Hook<"generic", "read", "before">;