firstly 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # firstly
 
+## 0.4.1
+
+### Patch Changes
+
+- [#250](https://github.com/jycouet/firstly/pull/250) [`53916ad`](https://github.com/jycouet/firstly/commit/53916ad519835a47e3598afb68ce6d84356af944) Thanks [@jycouet](https://github.com/jycouet)! - Add `firstly/sqlAdmin` module: a drop-in `<SqlAdmin />` Svelte component plus a `BackendMethod` controller gated by `Roles_SqlAdmin.SqlAdmin_Admin` (or `FF_Role.FF_Role_Admin`). The component ships with prefilled queries (DB size, table sizes, indexes) and logs results as `for AI: <rows>` to the browser console for chrome-devtools / AI-agent inspection. `sqlAdmin({ path })` logs an AI hint on server start pointing to the page (default `/sql/admin`).
+
+  Add `FF_Allow` and `FF_Filter` helpers (exported from `firstly`) for owner-only / admin-or-owner row checks and prefilters - usable in `allowApi*` and `apiPrefilter`. Both accept an entity generic (`FF_Allow.owner<Task>('userId')`) for type-safe column names; `col` defaults to `'userId'` if omitted. The `ownerOr<T>({ col?, roles })` variants are shortcuts for the "admin (or any role) OR owner" pattern.
+
+## 0.4.0
+
+### Minor Changes
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`b70967d`](https://github.com/jycouet/firstly/commit/b70967d0536298ec6659653da45eaa9e8b8e7fb0) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Remove unused legacy components from `firstly/svelte`: `FF_Cell` (+ `FF_Cell_Caption/Display/Edit/Error/Hint`), `FF_Form`, `FF_Grid`, `FF_Layout`, `FF_Config` (+ `ff_Config.svelte.ts` with `daisyTheme`, `defaultTheme`, `emptyTheme`, `getTheme`, `setTheme`, `getDynamicCustomField`, `setDynamicCustomField`, `getClasses`, `FF_Theme`). Also removed `customField.ts` (`DynamicCustomField`, `CellMetadata`, `FieldGroup`, `getLayout`, and the related `FieldOptions.ui` / `EntityOptions.ui.getLayout` Remult module augmentations). Drops the `FF_Repo.getLayout()` instance method and the `internals/select/Select2.svelte` internal.
+
+  Also deletes the duplicate dead `svelte/dialog/` tree (the canonical `dialog()` API is exported from `firstly/internals` and backed by `ui/dialog/`).
+
+  Internal: removes the `task` demo module and its demo routes (`demo/FF_Cell`, `demo/FF_Form_Grid`, `demo/FF_Layout`, `demo/FF_Simple`).
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`6589feb`](https://github.com/jycouet/firstly/commit/6589feba930250ffd842891f169faabfa498312b) Thanks [@jycouet](https://github.com/jycouet)! - Move `BaseEnum`, `FF_Entity`, `common` (`FF_Role`) source files from `lib/internals/` to `lib/core/`. The public export path is still `firstly/core`, which now also exports `FF_Role` (previously only available via `firstly/internals`) alongside the existing `BaseEnum`, `BaseEnumOptions`, `FF_Entity`, `isError`, `BaseItem`, `BaseItemLight`, `FF_Icon`. Consumers should migrate remaining `FF_Role` imports from `firstly/internals` to `firstly/core`.
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`c4d2ee4`](https://github.com/jycouet/firstly/commit/c4d2ee4a4b7a1441c985c62b55f9fbacbfe02b9b) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Fold `firstly/core` into the root `firstly` export.
+
+  `lib/utils/` (types + `tw`) moves into `lib/core/`. The `lib/core/index.ts` barrel is now empty — all core, frontend-safe primitives (`BaseEnum`, `BaseEnumOptions`, `BaseItem`, `BaseItemLight`, `FF_Icon`, `FF_Entity`, `FF_Role`, `isError`, `tryCatch`, `tryCatchSync`, `ResolvedType`, `UnArray`, `RecursivePartial`, `tw`) are re-exported from `lib/index.ts`, so consumers should import them from `'firstly'` directly.
+
+  The `./core` subpath is removed from `package.json` exports. Migrate `from 'firstly/core'` -> `from 'firstly'`.
+
+  Also moves the `RemultContext.feedbackOptions` module augmentation from `FeedbackController.ts` into `feedback/index.ts`, because some bundlers mangle `declare module 'remult'` inside a file that also has `@BackendMethod` decorators.
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`b382619`](https://github.com/jycouet/firstly/commit/b3826192a26e529c45f78dffa59f9955e92f3257) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Remove the `firstly` CLI.
+
+  The `bin` entry, the `./bin` export path, and `src/lib/bin/cmd.ts` are gone. Drops the `@clack/prompts` and `@kitql/internals` deps that only the CLI used.
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`64c4644`](https://github.com/jycouet/firstly/commit/64c4644d8c75d7b757a2d4a4128cd0b4f5799c50) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Remove the `firstly({ ... })` server wrapper and the `./server`, let's now just use remult Modules
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`a784113`](https://github.com/jycouet/firstly/commit/a784113217ba477fc36de3fee7ba6e82c8248cf5) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Remove `ModuleFF` and the `modulesFF` option.
+
+  Use `Module` from `remult/server` directly (it has all the same features: `key`, `priority`, `entities`, `controllers`, `initApi`, `initRequest`, nested `modules`). Remult also ships its own `modulesFlatAndOrdered`, so firstly's version is gone too. The `firstly({ ... })` wrapper now only accepts remult's native `modules` option.
+
+  Migration:
+
+  ```ts
+  // before
+  import { ModuleFF } from 'firstly/server'
+  new ModuleFF({ name: 'foo', modulesFF: [...] })
+
+  // after
+  import { Module } from 'remult/server'
+  new Module({ key: 'foo', modules: [...] })
+  ```
+
+  If you used `m.log`, create your own: `const log = new Log(key)` at module scope and reference it from `initApi` / `initRequest`.
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`7e49152`](https://github.com/jycouet/firstly/commit/7e49152d3af4f2ca40635ec0e1112a7ffa0de786) Thanks [@jycouet](https://github.com/jycouet)! - BREAKING: Remove the deprecated internal `sveltekit` module and the `RemultContext.setHeaders` / `setCookie` / `deleteCookie` augmentation it set up.
+
+  Nothing consumed those context methods. The module itself was marked `@deprecated` and was only auto-wired through `firstly({ ... })`. `remult.context.request` (the `RequestEvent`) is still augmented, so headers and cookies can be set via `remult.context.request.setHeaders(...)` / `remult.context.request.cookies.set(...)` directly.
+
+### Patch Changes
+
+- [#239](https://github.com/jycouet/firstly/pull/239) [`b70967d`](https://github.com/jycouet/firstly/commit/b70967d0536298ec6659653da45eaa9e8b8e7fb0) Thanks [@jycouet](https://github.com/jycouet)! - Bump deps: `nodemailer` 7 → 8 (+ `@types/nodemailer`), `tailwindcss` + `@tailwindcss/vite` 4.1.14 → 4.2.2, `vite-plugin-watch-and-run` 1.7.5 → 1.8.0, `@playwright/test` 1.58.2 → 1.59.1.
+
 ## 0.3.0
 
 ### Minor Changes

package/esm/SqlDatabase/FF_LogToConsole.js

@@ -16,7 +16,7 @@ const typeQuery = new Map([
     ['REVOKE', '🟫'], // Used to take back permissions from a user.
 ]);
 const keys = ['FROM', 'WHERE', 'LIMIT', 'OFFSET'];
-const typeQueryKey = Array.from(typeQuery.keys());
+const typeQueryKey = [...typeQuery.keys()];
 const log = new Log('');
 /**
  * @example
@@ -110,22 +110,17 @@ export const FF_LogToConsole = (duration, query, args, options) => {
     // 	final_s = final_s.replace(arg, yellow(args[arg]))
     // }
     const uniqueTables = [...new Set(tables)];
-    const mainTable = uniqueTables[uniqueTables.length - 1];
+    const mainTable = uniqueTables.at(-1) ?? '';
     const subTables = uniqueTables.slice(0, -1);
     const time = ` ${bgCyan((duration * 1000).toFixed(0).padStart(3) + ' ms ')}`;
-    let toLog = '';
     const withDetails = options?.withDetails === undefined ? true : options?.withDetails;
-    if (withDetails) {
-        toLog = `${typeQuery.get(first) || '💢'}` + time + ` ${final_s}`;
-    }
-    else {
-        toLog =
-            `${typeQuery.get(first) || '💢'}` +
-                `${time}` +
-                ` ${cyan(first)} ${green(mainTable?.replaceAll('"', ''))}` +
-                `${listArgs.length > 0 ? ` { ${listArgs.join(', ')} }` : ``}` +
-                `${subTables.length > 0 ? magenta(` (sub: ${subTables.join(', ')})`) : ``}`;
-    }
+    const toLog = withDetails
+        ? `${typeQuery.get(first) || '💢'}` + time + ` ${final_s}`
+        : `${typeQuery.get(first) || '💢'}` +
+            `${time}` +
+            ` ${cyan(first)} ${green(mainTable?.replaceAll('"', ''))}` +
+            `${listArgs.length > 0 ? ` { ${listArgs.join(', ')} }` : ``}` +
+            `${subTables.length > 0 ? magenta(` (sub: ${subTables.join(', ')})`) : ``}`;
     log.info(toLog);
     if (options?.ending) {
         options.ending(duration, query, args, tables);

package/esm/carbone/CarboneController.js

@@ -71,7 +71,7 @@ export class CarboneController {
     }
     static async deleteTemplate(config) {
         const { templateId } = config;
-        const response = await CarboneController.server.fetch({
+        await CarboneController.server.fetch({
             api: `/template/${templateId}`,
             method: 'DELETE',
         });
@@ -84,6 +84,7 @@ export class CarboneController {
     static async render(config) {
         const { templateName, templateBase64, data, filename } = config;
         let { templateId, convertTo } = config;
+        // eslint-disable-next-line
         let mode = '';
         if (templateBase64) {
             mode = 'templateBase64';

package/esm/changeLog/index.d.ts

@@ -46,9 +46,4 @@ export declare const withChangeLog: <entityType>(options?: EntityOptions<entityT
     apiRequireId?: import("remult").Allowed;
     dataProvider?: ((defaultDataProvider: import("remult").DataProvider) => import("remult").DataProvider | Promise<import("remult").DataProvider> | undefined | null) | undefined;
     changeLog?: false | ColumnDeciderArgs<entityType> | 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;
 };

package/esm/core/FF_Allow.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Row-level allow helpers (for `allowApiUpdate`, `allowApiDelete`, ...).
+ *
+ * Pair with `FF_Filter` (the equivalent for `apiPrefilter`).
+ *
+ * Pass the entity type as a generic (`FF_Allow.owner<Task>('userId')`) to get
+ * autocompletion and type-safety on the column name. Without a generic the
+ * column is just a `string`.
+ */
+export declare const FF_Allow: {
+    /**
+     * Allow only when the row's `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Owner-only update / delete (typed):
+     * ```ts
+     * import { FF_Entity, FF_Allow } from '..'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   allowApiUpdate: FF_Allow.owner<Task>('userId'), // typed: 'userId' must be a key of Task
+     *   allowApiDelete: FF_Allow.owner<Task>(),        // defaults to 'userId'
+     * })
+     * export class Task { ... }
+     * ```
+     *
+     * For "admin OR owner", prefer `FF_Allow.ownerOr` instead of inlining the
+     * combination yourself.
+     */
+    owner: <T>(col?: keyof T & string) => (entity?: T) => boolean;
+    /**
+     * Allow when the current user has any of the given `roles`, OR when the
+     * row's `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Admin OR owner (typed):
+     * ```ts
+     * import { FF_Entity, FF_Allow } from '..'
+     * import { Roles } from '../roles'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   allowApiUpdate: FF_Allow.ownerOr<Task>({ roles: [Roles.Admin] }),
+     *   allowApiDelete: FF_Allow.ownerOr<Task>({ col: 'createdBy', roles: [Roles.Admin] }),
+     * })
+     * export class Task { ... }
+     * ```
+     */
+    ownerOr: <T>({ col, roles }: {
+        col?: keyof T & string;
+        roles: string[];
+    }) => (entity?: T) => boolean;
+};

package/esm/core/FF_Allow.js

@@ -0,0 +1,54 @@
+import { remult } from 'remult';
+/**
+ * Row-level allow helpers (for `allowApiUpdate`, `allowApiDelete`, ...).
+ *
+ * Pair with `FF_Filter` (the equivalent for `apiPrefilter`).
+ *
+ * Pass the entity type as a generic (`FF_Allow.owner<Task>('userId')`) to get
+ * autocompletion and type-safety on the column name. Without a generic the
+ * column is just a `string`.
+ */
+export const FF_Allow = {
+    /**
+     * Allow only when the row's `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Owner-only update / delete (typed):
+     * ```ts
+     * import { FF_Entity, FF_Allow } from '..'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   allowApiUpdate: FF_Allow.owner<Task>('userId'), // typed: 'userId' must be a key of Task
+     *   allowApiDelete: FF_Allow.owner<Task>(),        // defaults to 'userId'
+     * })
+     * export class Task { ... }
+     * ```
+     *
+     * For "admin OR owner", prefer `FF_Allow.ownerOr` instead of inlining the
+     * combination yourself.
+     */
+    owner: (col = 'userId') => (entity) => !!remult.user?.id && entity?.[col] === remult.user.id,
+    /**
+     * Allow when the current user has any of the given `roles`, OR when the
+     * row's `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Admin OR owner (typed):
+     * ```ts
+     * import { FF_Entity, FF_Allow } from '..'
+     * import { Roles } from '../roles'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   allowApiUpdate: FF_Allow.ownerOr<Task>({ roles: [Roles.Admin] }),
+     *   allowApiDelete: FF_Allow.ownerOr<Task>({ col: 'createdBy', roles: [Roles.Admin] }),
+     * })
+     * export class Task { ... }
+     * ```
+     */
+    ownerOr: ({ col = 'userId', roles }) => (entity) => roles.some((r) => remult.isAllowed(r)) ||
+        (!!remult.user?.id && entity?.[col] === remult.user.id),
+};

package/esm/core/FF_Filter.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Prefilter helpers (for `apiPrefilter`, `backendPrefilter`).
+ *
+ * Pair with `FF_Allow` (the equivalent for `allowApi*` row checks).
+ *
+ * Pass the entity type as a generic (`FF_Filter.owner<Task>('userId')`) to get
+ * autocompletion and type-safety on the column name. Without a generic the
+ * column is just a `string`.
+ */
+export declare const FF_Filter: {
+    /**
+     * Prefilter rows where `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted. When anonymous, yields
+     * `IN (NULL)` which matches nothing.
+     *
+     * @example
+     * Owner-only prefilter (typed):
+     * ```ts
+     * import { FF_Entity, FF_Filter } from '..'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   apiPrefilter: () => FF_Filter.owner<Task>('userId'),
+     * })
+     * export class Task { ... }
+     * ```
+     *
+     * For "admin sees all, others see only their own", prefer
+     * `FF_Filter.ownerOr` instead of inlining the combination yourself.
+     */
+    owner: <T>(col?: keyof T & string) => any;
+    /**
+     * Prefilter that returns `{}` (no filter) when the current user has any of
+     * the given `roles`, otherwise restricts to rows where `col` equals the
+     * current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Admin sees all, others only their own (typed):
+     * ```ts
+     * import { FF_Entity, FF_Filter } from '..'
+     * import { Roles } from '../roles'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   apiPrefilter: () => FF_Filter.ownerOr<Task>({ roles: [Roles.Admin] }),
+     * })
+     * export class Task { ... }
+     * ```
+     */
+    ownerOr: <T>({ col, roles, }: {
+        col?: keyof T & string;
+        roles: string[];
+    }) => any;
+};

package/esm/core/FF_Filter.js

@@ -0,0 +1,57 @@
+import { remult } from 'remult';
+/**
+ * Prefilter helpers (for `apiPrefilter`, `backendPrefilter`).
+ *
+ * Pair with `FF_Allow` (the equivalent for `allowApi*` row checks).
+ *
+ * Pass the entity type as a generic (`FF_Filter.owner<Task>('userId')`) to get
+ * autocompletion and type-safety on the column name. Without a generic the
+ * column is just a `string`.
+ */
+export const FF_Filter = {
+    /**
+     * Prefilter rows where `col` equals the current user id.
+     *
+     * `col` defaults to `'userId'` if omitted. When anonymous, yields
+     * `IN (NULL)` which matches nothing.
+     *
+     * @example
+     * Owner-only prefilter (typed):
+     * ```ts
+     * import { FF_Entity, FF_Filter } from '..'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   apiPrefilter: () => FF_Filter.owner<Task>('userId'),
+     * })
+     * export class Task { ... }
+     * ```
+     *
+     * For "admin sees all, others see only their own", prefer
+     * `FF_Filter.ownerOr` instead of inlining the combination yourself.
+     */
+    owner: (col = 'userId') => ({ [col]: [remult.user?.id] }),
+    /**
+     * Prefilter that returns `{}` (no filter) when the current user has any of
+     * the given `roles`, otherwise restricts to rows where `col` equals the
+     * current user id.
+     *
+     * `col` defaults to `'userId'` if omitted.
+     *
+     * @example
+     * Admin sees all, others only their own (typed):
+     * ```ts
+     * import { FF_Entity, FF_Filter } from '..'
+     * import { Roles } from '../roles'
+     *
+     * \@FF_Entity<Task>('tasks', {
+     *   apiPrefilter: () => FF_Filter.ownerOr<Task>({ roles: [Roles.Admin] }),
+     * })
+     * export class Task { ... }
+     * ```
+     */
+    ownerOr: ({ col = 'userId', roles, }) => {
+        if (roles.some((r) => remult.isAllowed(r)))
+            return {};
+        return { [col]: [remult.user?.id] };
+    },
+};

package/esm/core/helper.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorInfo } from 'remult';
+export declare function isError<T>(object: any): object is ErrorInfo<T>;

package/esm/core/helper.js

@@ -0,0 +1,3 @@
+export function isError(object) {
+    return object;
+}

package/esm/core/index.js

@@ -0,0 +1,5 @@
+"use strict";
+// Files under lib/core/ are the pure-TS, frontend-safe primitives.
+// They are re-exported from lib/index.ts (the `firstly` root export).
+// Keep this barrel empty — import sources directly from ./BaseEnum,
+// ./FF_Entity, ./common, ./helper, ./tryCatch, ./types, ./tailwind.

package/esm/core/tailwind.d.ts

@@ -0,0 +1,21 @@
+import { type ClassValue } from 'clsx';
+/**
+ * Merges Tailwind CSS classes using clsx and tailwind-merge.
+ * This utility helps combine conditional classes and resolves conflicts.
+ *
+ * @param inputs - Class values to merge (strings, objects, arrays, etc.)
+ * @returns A merged string of Tailwind classes
+ *
+ * @example
+ * ```typescript
+ * import { tw } from './tailwind'
+ *
+ * const buttonClasses = tw(
+ *   'btn btn-primary',
+ *   isDisabled && 'btn-disabled',
+ *   size === 'lg' && 'btn-lg'
+ * )
+ * // Result: "btn btn-primary btn-disabled" (if isDisabled is true)
+ * ```
+ */
+export declare const tw: (...inputs: ClassValue[]) => string;

package/esm/core/tailwind.js

@@ -0,0 +1,22 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+/**
+ * Merges Tailwind CSS classes using clsx and tailwind-merge.
+ * This utility helps combine conditional classes and resolves conflicts.
+ *
+ * @param inputs - Class values to merge (strings, objects, arrays, etc.)
+ * @returns A merged string of Tailwind classes
+ *
+ * @example
+ * ```typescript
+ * import { tw } from './tailwind'
+ *
+ * const buttonClasses = tw(
+ *   'btn btn-primary',
+ *   isDisabled && 'btn-disabled',
+ *   size === 'lg' && 'btn-lg'
+ * )
+ * // Result: "btn btn-primary btn-disabled" (if isDisabled is true)
+ * ```
+ */
+export const tw = (...inputs) => twMerge(clsx(...inputs));

package/esm/core/tryCatch.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A successful result returned by `tryCatch` or `tryCatchSync`.
+ *
+ * @template T - The type of the resolved value.
+ */
+type Success<T> = {
+    data: T;
+    error: null;
+};
+/**
+ * A failure result returned by `tryCatch` or `tryCatchSync`.
+ *
+ * @template E - The type of the thrown error.
+ */
+type Failure<E> = {
+    data: null;
+    error: E;
+};
+/**
+ * A result wrapper that contains either a success value or an error.
+ *
+ * @template T - The type of the success value.
+ * @template E - The type of the error value.
+ */
+type Result<T, E = Error> = Success<T> | Failure<E>;
+/**
+ * Wraps an async promise and returns a `Result` object instead of throwing.
+ *
+ * @template T - The type of the resolved value.
+ * @template E - The type of the rejected error.
+ * @param promise - The promise to execute.
+ * @returns A result object with either `data` or `error`.
+ */
+export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+/**
+ * Wraps a synchronous function call and returns a `Result` object instead of throwing.
+ *
+ * @template T - The type of the returned value.
+ * @template E - The type of the thrown error.
+ * @param func - The synchronous function to execute.
+ * @returns A result object with either `data` or `error`.
+ */
+export declare function tryCatchSync<T, E = Error>(func: () => T): Result<T, E>;
+export {};

package/esm/core/tryCatch.js

@@ -0,0 +1,34 @@
+/**
+ * Wraps an async promise and returns a `Result` object instead of throwing.
+ *
+ * @template T - The type of the resolved value.
+ * @template E - The type of the rejected error.
+ * @param promise - The promise to execute.
+ * @returns A result object with either `data` or `error`.
+ */
+export async function tryCatch(promise) {
+    try {
+        const data = await promise;
+        return { data, error: null };
+    }
+    catch (error) {
+        return { data: null, error: error };
+    }
+}
+/**
+ * Wraps a synchronous function call and returns a `Result` object instead of throwing.
+ *
+ * @template T - The type of the returned value.
+ * @template E - The type of the thrown error.
+ * @param func - The synchronous function to execute.
+ * @returns A result object with either `data` or `error`.
+ */
+export function tryCatchSync(func) {
+    try {
+        const data = func();
+        return { data, error: null };
+    }
+    catch (error) {
+        return { data: null, error: error };
+    }
+}

package/esm/cron/server/index.js

@@ -98,7 +98,7 @@ export const cron = (jobsInfos) => {
                     jobs[topic].concurrentInProgress = jobs[topic].concurrentInProgress - 1;
                 }
                 else {
-                    const rCron = await repo(Cron).insert({ topic, status: 'skipped' });
+                    await repo(Cron).insert({ topic, status: 'skipped' });
                     logJobs(topic, job, `skipped because of concurrent limit (${yellow(concurrentToUse.toString())})`, false, false);
                 }
             };

package/esm/feedback/FeedbackController.js

@@ -204,8 +204,9 @@ repository(name: $repository, owner: $owner) {
         for (let i = 0; i < comments.length; i++) {
             if (comments[i].isMinimized) {
                 const parsed = JSON.parse(comments[i].body.replaceAll('<pre>\n', '').replaceAll('\n</pre>', ''));
-                items[items.length - 1].who = parsed?.author ?? '???';
-                items[items.length - 1].public = true;
+                const last = items.at(-1);
+                last.who = parsed?.author ?? '???';
+                last.public = true;
             }
             else {
                 const nbEye = comments[i].reactionGroups.find((c) => c.content === 'EYES')?.reactors.totalCount;

package/esm/feedback/index.d.ts

@@ -1,3 +1,8 @@
 import { FeedbackController } from './FeedbackController';
-import { default as Feedback } from './ui/Feedback.svelte';
-export { FeedbackController, Feedback };
+import type { FeedbackOptions } from './types';
+export { FeedbackController };
+declare module 'remult' {
+    interface RemultContext {
+        feedbackOptions: FeedbackOptions;
+    }
+}

package/esm/feedback/index.js

@@ -1,3 +1,2 @@
 import { FeedbackController } from './FeedbackController';
-import { default as Feedback } from './ui/Feedback.svelte';
-export { FeedbackController, Feedback };
+export { FeedbackController };

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

@@ -1,8 +1,3 @@
 import { Module } from 'remult/server';
 import type { FeedbackOptions } from '../types';
 export declare const feedback: (o: FeedbackOptions) => Module<unknown>;
-declare module 'remult' {
-    interface RemultContext {
-        feedbackOptions: FeedbackOptions;
-    }
-}

package/esm/feedback/server/index.js

@@ -5,7 +5,7 @@ export const feedback = (o) => {
     return new Module({
         key: 'feedback',
         controllers: [FeedbackController],
-        initRequest: async (kitEvent, op) => {
+        initRequest: async () => {
             remult.context.feedbackOptions = o;
         },
     });

package/esm/formats/strings.js

@@ -60,6 +60,7 @@ export const toTitleCase = (str) => {
 const rmvChars = (str, chars = ['<', '>', ',']) => {
     return chars.reduce((acc, char) => acc.replaceAll(char, ''), str).trim();
 };
+const extractMailRegex = /(.+)\s(.+)\s<(.+)>/i;
 export const extractMailInfo = (mail, withThrow = true) => {
     if (!mail) {
         if (withThrow) {
@@ -71,8 +72,7 @@ export const extractMailInfo = (mail, withThrow = true) => {
             email: '',
         };
     }
-    const regex = /(.+)\s(.+)\s<(.+)>/i;
-    const match = mail.match(regex);
+    const match = mail.match(extractMailRegex);
     if (match) {
         const firstName = toTitleCase(rmvChars(match[1].trim())).replaceAll(' ', '-');
         const lastName = rmvChars(match[2].trim()).toUpperCase();

package/esm/index.d.ts

@@ -3,3 +3,21 @@ export {
 /** alias for @kitql/helpers */
 h, };
 export declare const ff_Log: h.Log;
+export { BaseEnum } from './core/BaseEnum.js';
+export type { BaseEnumOptions, BaseItem, BaseItemLight, FF_Icon } from './core/BaseEnum.js';
+export { FF_Entity } from './core/FF_Entity.js';
+export { FF_Role } from './core/common.js';
+export { FF_Allow } from './core/FF_Allow.js';
+export { FF_Filter } from './core/FF_Filter.js';
+export { isError } from './core/helper.js';
+export { tryCatch, tryCatchSync } from './core/tryCatch.js';
+export type { ResolvedType, UnArray, RecursivePartial } from './core/types.js';
+export { tw } from './core/tailwind.js';
+export { FF_LogToConsole } from './SqlDatabase/FF_LogToConsole.js';
+export { FilterEntity } from './virtual/FilterEntity.js';
+export { UIEntity } from './virtual/UIEntity.js';
+declare module 'remult' {
+    interface FieldOptions<entityType, valueType> {
+        placeholder?: string;
+    }
+}

package/esm/index.js

@@ -3,3 +3,18 @@ export {
 /** alias for @kitql/helpers */
 h, };
 export const ff_Log = new h.Log('firstly');
+// ******************************
+// Core (pure TS, frontend-safe) - re-exported from lib/core/
+// ******************************
+export { BaseEnum } from './core/BaseEnum.js';
+export { FF_Entity } from './core/FF_Entity.js';
+export { FF_Role } from './core/common.js';
+export { FF_Allow } from './core/FF_Allow.js';
+export { FF_Filter } from './core/FF_Filter.js';
+export { isError } from './core/helper.js';
+export { tryCatch, tryCatchSync } from './core/tryCatch.js';
+export { tw } from './core/tailwind.js';
+// Misc primitives still exposed from the root.
+export { FF_LogToConsole } from './SqlDatabase/FF_LogToConsole.js';
+export { FilterEntity } from './virtual/FilterEntity.js';
+export { UIEntity } from './virtual/UIEntity.js';

package/esm/sqlAdmin/Roles_SqlAdmin.d.ts

@@ -0,0 +1,3 @@
+export declare const Roles_SqlAdmin: {
+    readonly SqlAdmin_Admin: "SqlAdmin.Admin";
+};

package/esm/sqlAdmin/Roles_SqlAdmin.js

@@ -0,0 +1,3 @@
+export const Roles_SqlAdmin = {
+    SqlAdmin_Admin: 'SqlAdmin.Admin',
+};

package/esm/sqlAdmin/SqlAdminController.d.ts

@@ -0,0 +1,9 @@
+import { SqlDatabase } from 'remult';
+export declare class SqlAdminController {
+    /** Optional override set by the `sqlAdmin()` module's `initApi`. Falls back to `SqlDatabase.getDb()`. */
+    static dp?: SqlDatabase;
+    static exec(cmd: string): Promise<{
+        r: import("remult").SqlResult;
+        took: number;
+    }>;
+}