firstly 0.1.2 → 0.2.0

package/esm/carbone/carboneEntities.js

@@ -0,0 +1,83 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CarbonLogAction_1;
+import { Entity, Field, Fields, remult, ValueListFieldType } from 'remult';
+import { Roles_Carbon } from './Roles_Carbon';
+let CarbonLogAction = class CarbonLogAction {
+    static { CarbonLogAction_1 = this; }
+    id;
+    static template_upload = new CarbonLogAction_1('TEMPLATE_UPLOAD');
+    static template_download = new CarbonLogAction_1('TEMPLATE_DOWNLOAD');
+    static template_delete = new CarbonLogAction_1('TEMPLATE_DELETE');
+    static render = new CarbonLogAction_1('RENDER');
+    constructor(id) {
+        this.id = id;
+    }
+};
+CarbonLogAction = CarbonLogAction_1 = __decorate([
+    ValueListFieldType()
+], CarbonLogAction);
+export { CarbonLogAction };
+let CarboneTemplate = class CarboneTemplate {
+    id;
+    updatedAt = new Date();
+    name;
+    extension = '';
+};
+__decorate([
+    Fields.string({ required: true })
+], CarboneTemplate.prototype, "id", void 0);
+__decorate([
+    Fields.updatedAt()
+], CarboneTemplate.prototype, "updatedAt", void 0);
+__decorate([
+    Fields.string({ required: true })
+], CarboneTemplate.prototype, "name", void 0);
+__decorate([
+    Fields.string({ required: true })
+], CarboneTemplate.prototype, "extension", void 0);
+CarboneTemplate = __decorate([
+    Entity('carboneTemplates', {
+        allowApiCrud: Roles_Carbon.Carbon_Admin,
+        allowApiRead: Roles_Carbon.Carbon_ViewTemplate,
+        defaultOrderBy: { updatedAt: 'desc' },
+    })
+], CarboneTemplate);
+export { CarboneTemplate };
+let CarboneLog = class CarboneLog {
+    id;
+    updatedAt = new Date();
+    userId = '';
+    action = CarbonLogAction.template_upload;
+    templateId = '';
+};
+__decorate([
+    Fields.id()
+], CarboneLog.prototype, "id", void 0);
+__decorate([
+    Fields.updatedAt()
+], CarboneLog.prototype, "updatedAt", void 0);
+__decorate([
+    Fields.string({
+        saving: (item) => {
+            item.userId = remult.user?.id ?? '';
+        },
+    })
+], CarboneLog.prototype, "userId", void 0);
+__decorate([
+    Field(() => CarbonLogAction)
+], CarboneLog.prototype, "action", void 0);
+__decorate([
+    Fields.string({ required: true })
+], CarboneLog.prototype, "templateId", void 0);
+CarboneLog = __decorate([
+    Entity('carboneLogs', {
+        allowApiCrud: Roles_Carbon.Carbon_Admin,
+        defaultOrderBy: { updatedAt: 'desc' },
+    })
+], CarboneLog);
+export { CarboneLog };

package/esm/carbone/index.d.ts

@@ -0,0 +1,29 @@
+import { Log } from '@kitql/helpers';
+import { CarboneLog, CarboneTemplate } from './carboneEntities';
+export { Roles_Carbon as Roles_Mail } from './Roles_Carbon';
+export declare const key = "carbone";
+export declare const log: Log;
+export declare const carbonEntities: {
+    CarboneTemplate: typeof CarboneTemplate;
+    CarboneLog: typeof CarboneLog;
+};
+/**
+ * Converts a File object to base64 string (without data URL prefix)
+ * @param file - The File object to convert
+ * @returns Promise<string> - Base64 string without data URL prefix
+ */
+export declare const fileToBase64: (file: File) => Promise<string>;
+/**
+ * Downloads a file from base64 data
+ * @param base64Data - The base64 encoded file data
+ * @param filename - The filename for the download
+ * @param contentType - The MIME type of the file
+ */
+export declare const downloadFile: (base64Data: string, filename: string, contentType: string) => void;
+/**
+ * File processing utilities for Carbone templates
+ */
+export declare const carboneFileUtils: {
+    fileToBase64: (file: File) => Promise<string>;
+    downloadFile: (base64Data: string, filename: string, contentType: string) => void;
+};

package/esm/carbone/index.js

@@ -0,0 +1,68 @@
+import { Log } from '@kitql/helpers';
+import { CarboneLog, CarboneTemplate } from './carboneEntities';
+export { Roles_Carbon as Roles_Mail } from './Roles_Carbon';
+export const key = 'carbone';
+export const log = new Log(key);
+export const carbonEntities = {
+    CarboneTemplate,
+    CarboneLog,
+};
+/**
+ * Converts a File object to base64 string (without data URL prefix)
+ * @param file - The File object to convert
+ * @returns Promise<string> - Base64 string without data URL prefix
+ */
+export const fileToBase64 = (file) => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = reader.result;
+            // Remove data URL prefix to get just the base64 content
+            const base64Content = result.split(',')[1];
+            resolve(base64Content);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+};
+/**
+ * Downloads a file from base64 data
+ * @param base64Data - The base64 encoded file data
+ * @param filename - The filename for the download
+ * @param contentType - The MIME type of the file
+ */
+export const downloadFile = (base64Data, filename, contentType) => {
+    try {
+        // Convert base64 to blob
+        const byteCharacters = atob(base64Data);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+            byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        const blob = new Blob([byteArray], { type: contentType });
+        // Create download link
+        const url = URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = filename;
+        link.style.display = 'none';
+        // Trigger download
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+        // Clean up
+        URL.revokeObjectURL(url);
+    }
+    catch (error) {
+        console.error('Download failed:', error);
+        throw error;
+    }
+};
+/**
+ * File processing utilities for Carbone templates
+ */
+export const carboneFileUtils = {
+    fileToBase64,
+    downloadFile,
+};

package/esm/carbone/server/CarboneServer.d.ts

@@ -0,0 +1,19 @@
+export declare class CarboneServer {
+    api_key: string;
+    api_url: string;
+    api_version: '5';
+    test: boolean;
+    constructor(options: {
+        CARBONE_API_KEY?: string;
+        api_url?: string;
+        api_version?: '5';
+        test?: boolean;
+    });
+    private getHeaders;
+    fetch: (o: {
+        api: string;
+        body?: string;
+        method?: "POST" | "GET" | "DELETE";
+        headers?: HeadersInit;
+    }) => Promise<Response>;
+}

package/esm/carbone/server/CarboneServer.js

@@ -0,0 +1,38 @@
+import { log } from '..';
+export class CarboneServer {
+    api_key;
+    api_url;
+    api_version;
+    test;
+    constructor(options) {
+        this.api_key = options.CARBONE_API_KEY ?? '';
+        this.api_url = options.api_url ?? 'https://api.carbone.io';
+        this.api_version = options.api_version ?? '5';
+        this.test = options.test ?? false;
+    }
+    getHeaders = (headersInit) => {
+        if (this.api_key === undefined || this.api_key === '') {
+            log.error('Token CARBONE_API_TOKEN not defined!');
+            throw new Error('Configuration error');
+        }
+        const headers = new Headers(headersInit);
+        headers.append('Authorization', 'Bearer ' + this.api_key);
+        headers.append('Carbone-version', this.api_version);
+        // headers.append('Carbone-version', 'staging')
+        headers.append('Content-type', 'application/json');
+        return headers;
+    };
+    fetch = async (o) => {
+        const response = await fetch(`${this.api_url}${o.api}`, {
+            method: o.method ?? 'POST',
+            headers: this.getHeaders(o.headers),
+            body: o.body,
+        });
+        if (!response.ok) {
+            const err = await response.json();
+            log.error(`Carbone render failed`, err);
+            throw new Error(err.error);
+        }
+        return response;
+    };
+}

package/esm/carbone/server/index.d.ts

@@ -0,0 +1,7 @@
+import { Module } from 'remult/server';
+export declare const carbone: (config: {
+    CARBONE_API_KEY?: string;
+    api_url?: string;
+    api_version?: "5";
+    test?: boolean;
+}) => Module<unknown>;

package/esm/carbone/server/index.js

@@ -0,0 +1,23 @@
+import { Module } from 'remult/server';
+import { carbonEntities, key, log } from '..';
+import { CarboneController } from '../CarboneController';
+import { CarboneServer } from './CarboneServer';
+export const carbone = (config) => {
+    return new Module({
+        key,
+        entities: Object.values(carbonEntities),
+        controllers: [CarboneController],
+        initApi: async () => {
+            if (config.CARBONE_API_KEY === undefined) {
+                log.error('CARBONE_API_KEY is required');
+            }
+            else {
+                CarboneController.server = new CarboneServer({
+                    ...config,
+                    test: config.test === undefined ? config.CARBONE_API_KEY.startsWith('test') : config.test,
+                });
+                log.success('initialized');
+            }
+        },
+    });
+};

package/esm/changeLog/changeLogEntities.js

@@ -19,7 +19,7 @@ let ChangeLog = class ChangeLog {
     deleted = false;
 };
 __decorate([
-    Fields.cuid()
+    Fields.id()
 ], ChangeLog.prototype, "id", void 0);
 __decorate([
     Fields.string()

package/esm/changeLog/index.d.ts

@@ -1,4 +1,4 @@
-import { type FieldRef, type FieldsRef, type LifecycleEvent } from 'remult';
+import { type EntityOptions, type FieldRef, type FieldsRef, type LifecycleEvent } from 'remult';
 import { Roles_ChangeLog, type change } from './changeLogEntities';
 export { Roles_ChangeLog };
 export type { change };
@@ -21,3 +21,39 @@ export declare class FieldDecider<entityType> {
     excludedValues: FieldRef<entityType>[];
     constructor(entity: entityType, options?: ColumnDeciderArgs<entityType>);
 }
+export declare const withChangeLog: <entityType>(options?: EntityOptions<entityType>) => {
+    saved: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<void>;
+    deleted: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<void>;
+    caption?: string;
+    label?: string;
+    allowApiRead?: import("remult").Allowed;
+    allowApiUpdate?: import("remult").AllowedForInstance<entityType> | undefined;
+    allowApiDelete?: import("remult").AllowedForInstance<entityType> | undefined;
+    allowApiInsert?: import("remult").AllowedForInstance<entityType> | undefined;
+    allowApiCrud?: import("remult").Allowed;
+    apiPrefilter?: import("remult").EntityFilter<entityType> | (() => import("remult").EntityFilter<entityType> | Promise<import("remult").EntityFilter<entityType>>) | undefined;
+    apiPreprocessFilter?: ((filter: import("remult").EntityFilter<entityType>, event: import("remult").PreprocessFilterEvent<entityType>) => import("remult").EntityFilter<entityType> | Promise<import("remult").EntityFilter<entityType>>) | undefined;
+    backendPreprocessFilter?: ((filter: import("remult").EntityFilter<entityType>, event: import("remult").PreprocessFilterEvent<entityType>) => import("remult").EntityFilter<entityType> | Promise<import("remult").EntityFilter<entityType>>) | undefined;
+    backendPrefilter?: import("remult").EntityFilter<entityType> | (() => import("remult").EntityFilter<entityType> | Promise<import("remult").EntityFilter<entityType>>) | undefined;
+    defaultOrderBy?: import("remult").EntityOrderBy<entityType> | undefined;
+    saving?: ((entity: entityType, event: LifecycleEvent<entityType>) => Promise<any> | any) | undefined;
+    deleting?: ((entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any) | undefined;
+    validation?: ((entity: entityType, ref: LifecycleEvent<entityType>) => Promise<any> | any) | undefined;
+    dbName?: string;
+    sqlExpression?: string | ((entity: import("remult").EntityMetadata<entityType>) => string | Promise<string>) | undefined;
+    id?: keyof import("remult").MembersOnly<entityType> | (keyof import("remult").MembersOnly<entityType>)[] | import("remult").EntityIdFields<entityType> | ((entity: import("remult").FieldsMetadata<entityType>) => import("remult").FieldMetadata | import("remult").FieldMetadata[]) | undefined;
+    entityRefInit?: ((ref: import("remult").EntityRef<entityType>, row: entityType) => void) | undefined;
+    apiRequireId?: import("remult").Allowed;
+    dataProvider?: ((defaultDataProvider: import("remult").DataProvider) => import("remult").DataProvider | Promise<import("remult").DataProvider> | undefined | null) | undefined;
+    ui?: {
+        getLayout?: import("../svelte/customField").getLayout<entityType> | undefined;
+    } | undefined;
+    searchableFind?: ((str: string) => import("remult").FindOptionsBase<entityType>) | undefined;
+    displayValue?: ((item: entityType) => import("../internals").BaseItem) | undefined;
+    permissionApiCrud?: import("../internals").BaseEnum[] | import("../internals").BaseEnum;
+    permissionApiDelete?: import("../internals").BaseEnum[] | import("../internals").BaseEnum;
+    permissionApiInsert?: import("../internals").BaseEnum[] | import("../internals").BaseEnum;
+    permissionApiRead?: import("../internals").BaseEnum[] | import("../internals").BaseEnum;
+    permissionApiUpdate?: import("../internals").BaseEnum[] | import("../internals").BaseEnum;
+    changeLog?: false | ColumnDeciderArgs<entityType> | undefined;
+};

package/esm/changeLog/index.js

@@ -95,3 +95,31 @@ export class FieldDecider {
         this.fields = meta.fields.toArray().filter((f) => !this.excludedFields.includes(f));
     }
 }
+export const withChangeLog = (options) => {
+    return {
+        ...options,
+        // changesLogs
+        saved: async (entity, e) => {
+            await options?.saved?.(entity, e);
+            if (options?.changeLog === false) {
+                // Don't log changes
+            }
+            else {
+                if (isBackend()) {
+                    await recordSaved(entity, e, options?.changeLog);
+                }
+            }
+        },
+        deleted: async (entity, e) => {
+            await options?.deleted?.(entity, e);
+            if (options?.changeLog === false) {
+                // Don't log changes
+            }
+            else {
+                if (isBackend()) {
+                    await recordDeleted(entity, e, options?.changeLog);
+                }
+            }
+        },
+    };
+};

package/esm/changeLog/server/index.d.ts

@@ -6,15 +6,28 @@ declare module 'remult' {
     }
 }
 /**
- * We suggest you to create your own `@APP_Entity` decorator and use it instead of `@Entity`.
- * Like this you opt-in to the change log feature Entity by Entity.
+ * ## Option 1
+ * Use the `withChangeLog` function to wrap your entity options.
+ *
+ * @example
+ * ```ts
+ * import { withChangeLog } from '..'
+ *
+ * \@Entity('users', withChangeLog({
+ *   // ...
+ * }))
+ * class User { }
+ * ```
+ * ## Option 2
+ * Create your own `@APP_Entity` decorator and use it instead of `@Entity`.
+ * Inside, it uses the `withChangeLog` function to wrap your entity options.
  *
  * @example
  * ```ts
  * // APP_Entity.ts example
  * import { Entity, isBackend, type EntityOptions } from 'remult'
  *
- * import { recordDeleted, recordSaved } from '..'
+ * import { withChangeLog } from '..'
  *
  * export function APP_Entity<entityType>(
  * 	key: string,
@@ -22,31 +35,7 @@ declare module 'remult' {
  * 		entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType
  * 	>,
  * ) {
- * 	return Entity(key, {
- * 		...options,
- *
- * 		// changesLogs
- * 		saved: async (entity, e) => {
- * 			await options?.saved?.(entity, e)
- * 			if (options?.changeLog === false) {
- * 				// Don't log changes
- * 			} else {
- * 				if (isBackend()) {
- * 					await recordSaved(entity, e, options?.changeLog)
- * 				}
- * 			}
- * 		},
- * 		deleted: async (entity, e) => {
- * 			await options?.deleted?.(entity, e)
- * 			if (options?.changeLog === false) {
- * 				// Don't log changes
- * 			} else {
- * 				if (isBackend()) {
- * 					await recordDeleted(entity, e, options?.changeLog)
- * 				}
- * 			}
- * 		},
- * 	})
+ * 	return Entity(key, withChangeLog(options))
  * }
  * ```
  */

package/esm/changeLog/server/index.js

@@ -1,15 +1,28 @@
 import { Module } from 'remult/server';
 import { ChangeLog } from '../changeLogEntities';
 /**
- * We suggest you to create your own `@APP_Entity` decorator and use it instead of `@Entity`.
- * Like this you opt-in to the change log feature Entity by Entity.
+ * ## Option 1
+ * Use the `withChangeLog` function to wrap your entity options.
+ *
+ * @example
+ * ```ts
+ * import { withChangeLog } from '..'
+ *
+ * \@Entity('users', withChangeLog({
+ *   // ...
+ * }))
+ * class User { }
+ * ```
+ * ## Option 2
+ * Create your own `@APP_Entity` decorator and use it instead of `@Entity`.
+ * Inside, it uses the `withChangeLog` function to wrap your entity options.
  *
  * @example
  * ```ts
  * // APP_Entity.ts example
  * import { Entity, isBackend, type EntityOptions } from 'remult'
  *
- * import { recordDeleted, recordSaved } from '..'
+ * import { withChangeLog } from '..'
  *
  * export function APP_Entity<entityType>(
  * 	key: string,
@@ -17,31 +30,7 @@ import { ChangeLog } from '../changeLogEntities';
  * 		entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType
  * 	>,
  * ) {
- * 	return Entity(key, {
- * 		...options,
- *
- * 		// changesLogs
- * 		saved: async (entity, e) => {
- * 			await options?.saved?.(entity, e)
- * 			if (options?.changeLog === false) {
- * 				// Don't log changes
- * 			} else {
- * 				if (isBackend()) {
- * 					await recordSaved(entity, e, options?.changeLog)
- * 				}
- * 			}
- * 		},
- * 		deleted: async (entity, e) => {
- * 			await options?.deleted?.(entity, e)
- * 			if (options?.changeLog === false) {
- * 				// Don't log changes
- * 			} else {
- * 				if (isBackend()) {
- * 					await recordDeleted(entity, e, options?.changeLog)
- * 				}
- * 			}
- * 		},
- * 	})
+ * 	return Entity(key, withChangeLog(options))
  * }
  * ```
  */

package/esm/cron/Cron.js

@@ -16,7 +16,7 @@ let Cron = class Cron {
     status = 'starting';
 };
 __decorate([
-    Fields.cuid()
+    Fields.id()
 ], Cron.prototype, "id", void 0);
 __decorate([
     Fields.string({ required: true })

package/esm/index.d.ts

@@ -1,3 +1,5 @@
-import * as log from '@kitql/helpers';
-export { log };
-export declare const ff_Log: log.Log;
+import * as h from '@kitql/helpers';
+export { 
+/** alias for @kitql/helpers */
+h, };
+export declare const ff_Log: h.Log;

package/esm/index.js

@@ -1,3 +1,5 @@
-import * as log from '@kitql/helpers';
-export { log };
-export const ff_Log = new log.Log('firstly');
+import * as h from '@kitql/helpers';
+export { 
+/** alias for @kitql/helpers */
+h, };
+export const ff_Log = new h.Log('firstly');

package/esm/internals/FF_Entity.js

@@ -1,5 +1,5 @@
-import { Entity, isBackend } from 'remult';
-import { recordDeleted, recordSaved } from '../changeLog';
+import { Entity } from 'remult';
+import { withChangeLog } from '../changeLog';
 const toAllow = (permission) => {
     if (permission) {
         if (Array.isArray(permission)) {
@@ -10,35 +10,12 @@ const toAllow = (permission) => {
     return undefined;
 };
 export function FF_Entity(key, options) {
-    return Entity(key, {
+    return Entity(key, withChangeLog({
         ...options,
         allowApiCrud: options?.allowApiCrud ?? toAllow(options?.permissionApiCrud),
         allowApiDelete: options?.allowApiDelete ?? toAllow(options?.permissionApiDelete),
         allowApiInsert: options?.allowApiInsert ?? toAllow(options?.permissionApiInsert),
         allowApiRead: options?.allowApiRead ?? toAllow(options?.permissionApiRead),
         allowApiUpdate: options?.allowApiUpdate ?? toAllow(options?.permissionApiUpdate),
-        // changesLogs
-        saved: async (entity, e) => {
-            await options?.saved?.(entity, e);
-            if (options?.changeLog === false) {
-                // Don't log changes
-            }
-            else {
-                if (isBackend()) {
-                    await recordSaved(entity, e, options?.changeLog);
-                }
-            }
-        },
-        deleted: async (entity, e) => {
-            await options?.deleted?.(entity, e);
-            if (options?.changeLog === false) {
-                // Don't log changes
-            }
-            else {
-                if (isBackend()) {
-                    await recordDeleted(entity, e, options?.changeLog);
-                }
-            }
-        },
-    });
+    }));
 }

package/esm/internals/FF_Fields.d.ts

@@ -1,9 +1,10 @@
-import { type FieldOptions, type StringFieldOptions } from 'remult';
+import { type ClassType, type FieldOptions, type StringFieldOptions } from 'remult';
+import type { BaseEnum } from './BaseEnum';
 export declare class FF_Fields {
     static string<entityType = unknown, valueType = string>(o?: StringFieldOptions<entityType, valueType>): import("remult").ClassFieldDecorator<entityType, valueType | undefined>;
     static currency<entityType = unknown>(o?: FieldOptions<entityType, number>): import("remult").ClassFieldDecorator<entityType, number | undefined>;
     static dateOnly<entityType = any>(o?: FieldOptions<entityType, Date>): import("remult").ClassFieldDecorator<entityType, Date | undefined>;
     static arrayEnum<enumType = any, entityType = any>(enumClass: enumType, o?: FieldOptions<entityType, any[]>): import("remult").ClassFieldDecorator<entityType, any[] | undefined>;
     static arrayEnumToGql<enumType = any, entityType = any>(enumClass: enumType, o?: FieldOptions<entityType, any[]>): import("remult").ClassFieldDecorator<entityType, any[] | undefined>;
-    static arrayValueList<enumType = any, entityType = any>(enumClass: enumType, o?: FieldOptions<entityType, any[]>): import("remult").ClassFieldDecorator<entityType, any[] | undefined>;
+    static arrayValueList<enumType = any, entityType = any>(enumClass: ClassType<BaseEnum<any>>, o?: FieldOptions<entityType, any[]>): import("remult").ClassFieldDecorator<entityType, any[] | undefined>;
 }

package/esm/internals/FF_Fields.js

@@ -155,18 +155,22 @@ export class FF_Fields {
                 fromDb: (v) => {
                     if (!v)
                         return [];
-                    const keys = v
-                        // @ts-ignore
-                        .map((s) => {
-                        // @ts-ignore
-                        return enumClass[s];
-                    })
-                        .filter((p) => p !== undefined);
-                    return keys;
+                    const arr = Array.isArray(v)
+                        ? v
+                        : v?.split(',').flatMap((c) => c.replaceAll('{', '').replaceAll('}', ''));
+                    const list = getEnums(enumClass);
+                    const toRet = [];
+                    for (const s of arr) {
+                        const found = list.find((c) => c.id === s);
+                        if (found) {
+                            toRet.push(found);
+                        }
+                    }
+                    return toRet;
                 },
                 toDb: (v) => {
                     const arr = Array.isArray(v) ? v : [v];
-                    return `{${[...new Set((arr ?? []).map((c) => c.id))].join(',')}}`;
+                    return `{${[...new Set((arr.filter((c) => c !== undefined) ?? []).map((c) => c.id))].join(',')}}`;
                 },
                 displayValue: (v) => {
                     // Nice to have a oneLiner, but if you want custom style, just take the array and do what you want

package/esm/internals/index.d.ts

@@ -57,7 +57,7 @@ declare module 'remult' {
         suffixEdit?: string;
         suffixEditWithS?: boolean;
         styleRadioUntil?: number;
-        step?: '1' | '0.1' | '0.01';
+        step?: '1' | '0.1' | '0.01' | '0.5';
         href?: (item: entityType) => string;
         findOptionsForEdit?: ((entity: entityType) => FindOptionsBase<valueType>) | FindOptionsBase<valueType>;
         findOptionsLimit?: number;

package/esm/mail/Mail.js

@@ -18,7 +18,7 @@ let Mail = class Mail {
     errorInfo = '';
 };
 __decorate([
-    Fields.cuid()
+    Fields.id()
 ], Mail.prototype, "id", void 0);
 __decorate([
     Fields.createdAt()

package/esm/svelte/FF_Cell.svelte

@@ -15,6 +15,7 @@
 		class?: string
 	}
 
+	// eslint-disable-next-line svelte/no-unused-props
 	let props: Props<valueType, entityType> = $props()
 
 	// let classes = $derived(getClasses('field', props.classes))