firstly 0.0.1 → 0.0.2

package/esm/index.js

@@ -0,0 +1,42 @@
+import 'remult';
+import { Log } from '@kitql/helpers';
+import { kitStoreItem } from './kitStoreItem.js';
+import { kitStoreList } from './kitStoreList.js';
+import { default as Button } from './ui/Button.svelte';
+import { default as Clipboardable } from './ui/Clipboardable.svelte';
+import { default as DialogManagement } from './ui/dialog/DialogManagement.svelte';
+import { default as FormEditAction } from './ui/dialog/FormEditAction.svelte';
+import { default as Field } from './ui/Field.svelte';
+import { default as FieldGroup } from './ui/FieldGroup.svelte';
+import { default as Grid } from './ui/Grid.svelte';
+import { default as GridPaginate } from './ui/GridPaginate.svelte';
+import { default as Icon } from './ui/Icon.svelte';
+import { default as FieldContainer } from './ui/internals/FieldContainer.svelte';
+import { default as SelectMelt } from './ui/internals/select/SelectMelt.svelte';
+import { default as Link } from './ui/link/Link.svelte';
+import { default as LinkPlus } from './ui/link/LinkPlus.svelte';
+import { default as Loading } from './ui/Loading.svelte';
+import { default as Tooltip } from './ui/Tooltip.svelte';
+export const logFirstly = new Log('firstly');
+export const KitRole = {
+    Admin: 'KitAdmin',
+};
+export { Field, FormEditAction, Grid, GridPaginate, FieldGroup, Icon, Link, LinkPlus, Loading, Button, Tooltip, DialogManagement, FieldContainer, SelectMelt, Clipboardable, };
+export { dialog } from './ui/dialog/dialog.js';
+export { KitBaseEnum, getEnum, getEnums } from './KitBaseEnum.js';
+export { KitFields } from './KitFields.js';
+export { KitEntity } from './KitEntity.js';
+export { LogToConsoleCustom } from './SqlDatabase/LogToConsoleCustom.js';
+export { getEntityDisplayValue, isError, kitDbNamesOf, getFieldLinkDisplayValue } from './helper.js';
+export { buildWhere, getPlaceholder, buildSearchWhere, kitCellsBuildor, kitCellBuildor, fieldsOf, } from './kitCellsBuildor.js';
+export { kitStoreItem };
+export { kitStoreList };
+export { FilterEntity } from './virtual/FilterEntity.js';
+export { UIEntity } from './virtual/UIEntity.js';
+// Icons
+export { LibIcon_Empty, LibIcon_Forbidden, LibIcon_ChevronDown, LibIcon_ChevronUp, LibIcon_ChevronLeft, LibIcon_ChevronRight, LibIcon_Search, LibIcon_Check, LibIcon_MultiCheck, LibIcon_Add, LibIcon_MultiAdd, LibIcon_Edit, LibIcon_Delete, LibIcon_Cross, LibIcon_Save, LibIcon_Man, LibIcon_Woman, LibIcon_Send, LibIcon_Load, LibIcon_Settings, LibIcon_Sort, LibIcon_SortAsc, LibIcon_SortDesc, } from './ui/LibIcon.js';
+// Formats & Utils
+export { displayPhone, arrToStr } from './formats/strings.js';
+export { displayCurrency } from './formats/numbers.js';
+export { tw } from './utils/tailwind.js';
+export { litOrStr } from './utils/types.js';

package/esm/kitCellsBuildor.d.ts

@@ -0,0 +1,45 @@
+import type { SvelteComponent } from 'svelte';
+import { type EntityFilter, type FieldMetadata, type Repository } from 'remult';
+import type { UnArray } from './utils/types.js';
+export type VisibilityMode = 'view' | 'edit' | 'hide';
+type KitCellInternal<Entity> = {
+    col?: keyof Entity;
+    kind?: 'field' | 'field_link' | 'entity_link' | 'slot' | 'header' | 'component';
+    class?: string;
+    header?: string;
+    headerSlot?: boolean;
+    modeEdit?: VisibilityMode;
+    modeView?: VisibilityMode;
+    clipboardable?: boolean;
+    clearable?: boolean;
+    component?: new (...args: any[]) => SvelteComponent;
+    props?: any;
+    rowToProps?: (row: any) => any;
+};
+export type KitCell<Entity> = KitCellInternal<Entity> & {
+    field?: FieldMetadata<any, Entity>;
+};
+export type KitCellsInput<Entity> = (keyof Entity | KitCellInternal<Entity>)[];
+/**
+ * kitCellsBuildor is a function to build cells for a <Grid /> or <FieldGroup /> component.
+ *
+ * ```html
+ * <script lang="ts">
+ *   import { repo } from 'remult'
+ *
+ *   const cells = kitCellsBuildor(repo(Site), ['name', 'description'])
+ *   const store = kitStoreList( repo(Site) )
+ *   $: store.fetch()
+ * </script>
+ *
+ * <Grid {cells} {store} />
+ * ```
+ *
+ */
+export declare function kitCellsBuildor<Entity>(repo: Repository<Entity>, inputBuildor: KitCellsInput<Entity>): KitCell<Entity>[];
+export declare function kitCellBuildor<Entity>(repo: Repository<Entity>, inputBuildor: UnArray<KitCellsInput<Entity>>): KitCell<Entity>;
+export declare const fieldsOf: <Entity>(b: KitCell<Entity>[]) => FieldMetadata<any, Entity>[];
+export declare const getPlaceholder: <Entity>(fields: FieldMetadata<any, Entity>[]) => string;
+export declare const buildSearchWhere: <Entity>(fields: FieldMetadata<any, Entity>[], search?: string | null) => EntityFilter<Entity>[];
+export declare const buildWhere: <Entity>(defaultWhere: EntityFilter<Entity> | undefined, fields_filter: FieldMetadata<any, Entity>[], fields_search: FieldMetadata<any, Entity>[], obj: Record<string, string>) => EntityFilter<Entity>;
+export {};

package/esm/kitCellsBuildor.js

@@ -0,0 +1,105 @@
+import {} from 'remult';
+import { getRelationFieldInfo } from 'remult/internals';
+import { getEnum, KitBaseEnum } from './KitBaseEnum.js';
+/**
+ * kitCellsBuildor is a function to build cells for a <Grid /> or <FieldGroup /> component.
+ *
+ * ```html
+ * <script lang="ts">
+ *   import { repo } from 'remult'
+ *
+ *   const cells = kitCellsBuildor(repo(Site), ['name', 'description'])
+ *   const store = kitStoreList( repo(Site) )
+ *   $: store.fetch()
+ * </script>
+ *
+ * <Grid {cells} {store} />
+ * ```
+ *
+ */
+export function kitCellsBuildor(repo, inputBuildor) {
+    const buildor = [];
+    for (let i = 0; i < inputBuildor.length; i++) {
+        const item = inputBuildor[i];
+        let b;
+        if (item instanceof Object) {
+            b = { ...item, field: repo.fields[item.col] };
+        }
+        else {
+            b = { col: item, field: repo.fields[item] };
+        }
+        // Let's tweak defaults...
+        if (b.kind === undefined) {
+            if (b.field?.options.href) {
+                b.kind = 'field_link';
+            }
+        }
+        buildor.push(b);
+    }
+    return buildor;
+}
+export function kitCellBuildor(repo, inputBuildor) {
+    return kitCellsBuildor(repo, [inputBuildor])[0];
+}
+export const fieldsOf = (b) => {
+    return b.filter((c) => c.field).map((c) => c.field) ?? [];
+};
+export const getPlaceholder = (fields) => {
+    return fields.map((c) => c.caption).join(', ');
+};
+export const buildSearchWhere = (fields, search) => {
+    if (!search) {
+        return [];
+    }
+    const f = [
+        {
+            $or: fields.map((f) => {
+                if (f.inputType === 'number') {
+                    return { [f.key]: search };
+                }
+                const sSplitted = search.split(' ');
+                return {
+                    $and: sSplitted.map((s) => ({ [f.key]: { $contains: s } })),
+                };
+            }),
+        },
+    ];
+    return f;
+};
+export const buildWhere = (defaultWhere, fields_filter, fields_search, obj) => {
+    const and = [];
+    if (defaultWhere) {
+        and.push(defaultWhere);
+    }
+    if (obj.search) {
+        and.push(...buildSearchWhere(fields_search, obj.search));
+    }
+    for (const field of fields_filter) {
+        const rfi = getRelationFieldInfo(field);
+        // if there is a value
+        if (obj[field.key]) {
+            if (field.inputType === 'checkbox') {
+                // @ts-ignore
+                and.push({ [field.key]: obj[field.key] });
+            }
+            else if (field.inputType === 'selectEnum') {
+                // @ts-ignore
+                const theEnum = getEnum(field, obj[field.key]);
+                // Take the where of the enum if it exists, or it's using this selection as a filter
+                // @ts-ignore
+                const wheretoUse = theEnum?.where ?? new KitBaseEnum(obj[field.key]);
+                // @ts-ignore
+                and.push({ [field.key]: wheretoUse });
+            }
+            else if (rfi.type === 'toOne') {
+                // @ts-ignore (stting the id of the relation)
+                and.push({ [field.key]: obj[field.key] });
+            }
+            else {
+                console.info(`Not handled filter field ${field.key} ${field.inputType}`);
+            }
+        }
+    }
+    // @ts-ignore
+    return { $and: and };
+};

package/esm/kitStoreItem.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="svelte" />
+import type { ErrorInfo, FindOptions, Repository } from 'remult';
+type TheStoreItem<T> = {
+    item: T | undefined;
+    loading?: boolean;
+    errors: ErrorInfo<T> | undefined;
+    globalError?: string | undefined;
+};
+export declare const kitStoreItem: <T>(repo: Repository<T>, initValues?: TheStoreItem<T>) => {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<TheStoreItem<T>>, invalidate?: import("svelte/store").Invalidator<TheStoreItem<T>> | undefined) => import("svelte/store").Unsubscriber;
+    create: (item: Partial<T>) => void;
+    set: (newItem: TheStoreItem<T>) => void;
+    /**
+     * if you have keys, build the id with
+     * ```ts
+     * const id = repo.metadata.idMetadata.getId({a:1,b:2})
+     * store.fetch(id)
+     * ```
+     */
+    fetch: (id: Parameters<Repository<T>['findId']>[0], options?: FindOptions<T>, onNewData?: ((item: T) => void) | undefined) => Promise<void>;
+    /**
+     * `.save()` will `update` or `insert` the current item.
+     */
+    save: () => Promise<T | undefined>;
+    delete: () => Promise<void>;
+    onChange: (prop: keyof T, callback: (newValue: any, oldValue: any) => void) => void;
+};
+export {};

package/esm/kitStoreItem.js

@@ -0,0 +1,170 @@
+import { BROWSER } from 'esm-env';
+import { derived, get, writable } from 'svelte/store';
+import { Log } from '@kitql/helpers';
+import { isError } from './helper';
+export const kitStoreItem = (repo, initValues = {
+    item: undefined,
+    loading: true,
+    errors: undefined,
+    globalError: undefined,
+}) => {
+    const internalStore = writable(initValues);
+    // Function to watch changes on a specific property of `item`
+    const onChange = (prop, callback) => {
+        const itemProperty = derived(internalStore, ($s) => $s.item && $s.item[prop]);
+        let oldValue;
+        // Subscribe to the derived store to monitor changes
+        itemProperty.subscribe((newValue) => {
+            if (newValue !== oldValue) {
+                if (oldValue !== undefined) {
+                    // to avoid running on initial undefined state
+                    callback(newValue, oldValue);
+                }
+                oldValue = newValue;
+            }
+        });
+    };
+    return {
+        subscribe: internalStore.subscribe,
+        create: (item) => {
+            internalStore.set({
+                item: repo.create(item),
+                loading: false,
+                errors: {},
+                globalError: undefined,
+            });
+        },
+        // set: internalStore.set,
+        set: (newItem) => {
+            internalStore.update((s) => {
+                return { ...newItem };
+            });
+        },
+        /**
+         * if you have keys, build the id with
+         * ```ts
+         * const id = repo.metadata.idMetadata.getId({a:1,b:2})
+         * store.fetch(id)
+         * ```
+         */
+        fetch: async (id, options, onNewData) => {
+            if (BROWSER) {
+                internalStore.update((s) => ({ ...s, loading: true }));
+                try {
+                    const item = await repo.findId(id, options);
+                    // lastOptions = options
+                    internalStore.update((s) => ({
+                        ...s,
+                        loading: false,
+                        item,
+                        errors: undefined,
+                        globalError: undefined,
+                    }));
+                    if (onNewData) {
+                        onNewData(item);
+                    }
+                }
+                catch (error) {
+                    if (isError(error)) {
+                        internalStore.update((s) => ({
+                            ...s,
+                            loading: false,
+                            item: {},
+                            errors: {},
+                            // @ts-ignore
+                            globalError: error.message,
+                        }));
+                    }
+                }
+            }
+        },
+        /**
+         * `.save()` will `update` or `insert` the current item.
+         */
+        save: async () => {
+            const s = get(internalStore);
+            try {
+                if (!s.item) {
+                    return;
+                }
+                const item = await repo.save(s.item);
+                internalStore.update((s) => ({
+                    ...s,
+                    loading: false,
+                    item,
+                    errors: undefined,
+                    globalError: undefined,
+                }));
+                return item;
+            }
+            catch (error) {
+                if (isError(error)) {
+                    if (!error.modelState) {
+                        internalStore.update((s) => ({
+                            ...s,
+                            loading: false,
+                            item: s.item,
+                            errors: undefined,
+                            globalError: error.message,
+                        }));
+                    }
+                    else {
+                        const errors = {};
+                        for (const key in error.modelState) {
+                            // @ts-ignore
+                            errors[key] = error.modelState[key];
+                        }
+                        internalStore.update((s) => ({
+                            ...s,
+                            loading: false,
+                            item: s.item,
+                            errors,
+                            globalError: undefined,
+                        }));
+                    }
+                }
+                // After we updated everything, let's throw the error
+                throw error;
+            }
+        },
+        delete: async () => {
+            const s = get(internalStore);
+            if (!s.item) {
+                new Log('firstly').error(`To delete an item, you need set it first.`);
+                return;
+            }
+            try {
+                await repo.delete(s.item);
+            }
+            catch (error) {
+                if (isError(error)) {
+                    if (!error.modelState) {
+                        internalStore.update((s) => ({
+                            ...s,
+                            loading: false,
+                            item: s.item,
+                            errors: undefined,
+                            globalError: error.message,
+                        }));
+                    }
+                    else {
+                        const errors = {};
+                        for (const key in error.modelState) {
+                            // @ts-ignore
+                            errors[key] = error.modelState[key];
+                        }
+                        internalStore.update((s) => ({
+                            ...s,
+                            loading: false,
+                            item: s.item,
+                            errors,
+                            globalError: undefined,
+                        }));
+                    }
+                }
+                throw error;
+            }
+        },
+        onChange,
+    };
+};

package/esm/kitStoreList.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="svelte" />
+import type { FindOptions, Repository } from 'remult';
+type TheStoreList<T> = {
+    items: T[];
+    loading: boolean;
+    totalCount: number | undefined;
+};
+export type FindOptionsPlus<T> = FindOptions<T> & {
+    withCount?: boolean;
+    withItems?: boolean;
+};
+/**
+ * @param repo remult repository to listen to
+ * @param initValues usually the data coming from SSR
+ * @returns a store with the initial values and a listen() method to subscribe to changes
+ *
+ * Example
+ * ```ts
+ * // get the repo
+ * const taskRepo = remult.repo(Task)
+ *
+ * const tasks = kitStore(taskRepo, data.tasks)
+ * $: browser && tasks.listen(data.options)
+ * ```
+ */
+export declare const kitStoreList: <T>(repo: Repository<T>, initValues?: TheStoreList<T>) => {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<TheStoreList<T>>, invalidate?: import("svelte/store").Invalidator<TheStoreList<T>> | undefined) => import("svelte/store").Unsubscriber;
+    manualSet: (info: TheStoreList<T>) => void;
+    fetch: (options?: FindOptionsPlus<T>, onNewData?: ((items?: T[], totalCount?: number) => void) | undefined) => Promise<void>;
+    listen: (options?: FindOptionsPlus<T>) => Promise<void>;
+    getRepo: () => Repository<T>;
+};
+export {};

package/esm/kitStoreList.js

@@ -0,0 +1,98 @@
+import { BROWSER } from 'esm-env';
+import { onDestroy } from 'svelte';
+import { writable } from 'svelte/store';
+/**
+ * @param repo remult repository to listen to
+ * @param initValues usually the data coming from SSR
+ * @returns a store with the initial values and a listen() method to subscribe to changes
+ *
+ * Example
+ * ```ts
+ * // get the repo
+ * const taskRepo = remult.repo(Task)
+ *
+ * const tasks = kitStore(taskRepo, data.tasks)
+ * $: browser && tasks.listen(data.options)
+ * ```
+ */
+export const kitStoreList = (repo, initValues = { items: [], loading: true, totalCount: undefined }) => {
+    const { subscribe, set, update } = writable(initValues);
+    let unSub = null;
+    onDestroy(async () => {
+        await plzUnSub();
+    });
+    // if we already have a subscription, unsubscribe (on option update for example)
+    const plzUnSub = async () => {
+        if (unSub) {
+            await unSub();
+            unSub = null;
+        }
+    };
+    return {
+        subscribe,
+        // set,
+        manualSet: (info) => {
+            set(info);
+        },
+        fetch: async (options, onNewData) => {
+            if (BROWSER) {
+                update((s) => ({ ...s, loading: true }));
+                const withCount = options?.withCount ?? false;
+                const withItems = options?.withItems ?? true;
+                if (!withItems && !withCount) {
+                    throw new Error(`xxx.fetch() withItems and withCount can't be both false!`);
+                }
+                else if (!withItems && withCount) {
+                    const totalCount = await repo.count(options?.where);
+                    set({ loading: false, items: [], totalCount });
+                    if (onNewData) {
+                        onNewData(undefined, totalCount);
+                    }
+                }
+                else if (withItems && !withCount) {
+                    const items = await repo.find(options);
+                    set({ loading: false, items, totalCount: undefined });
+                    if (onNewData) {
+                        onNewData(items, undefined);
+                    }
+                }
+                else {
+                    const [items, totalCount] = await Promise.all([
+                        repo.find({ ...options }),
+                        repo.count(options?.where),
+                    ]);
+                    set({ loading: false, items, totalCount });
+                    if (onNewData) {
+                        onNewData(items, totalCount);
+                    }
+                }
+            }
+        },
+        listen: async (options) => {
+            if (BROWSER) {
+                await plzUnSub();
+                unSub = repo.liveQuery({ ...options }).subscribe(async (info) => {
+                    const withCount = options?.withCount ?? false;
+                    let totalCount = undefined;
+                    if (withCount) {
+                        totalCount = await repo.count(options?.where);
+                    }
+                    update((c) => {
+                        return { ...c, items: info.items, loading: false, ...(withCount ? { totalCount } : {}) };
+                    });
+                });
+            }
+            else {
+                throw new Error(`xxx.listen() Too early!
+
+You should do like: 
+  let tasks = tasksStore<Task>(taskRepo, data.tasks)
+  $: browser && tasks.listen()
+				`);
+            }
+        },
+        getRepo: () => {
+            return repo;
+        },
+    };
+};

package/esm/mail/index.d.ts

@@ -0,0 +1,11 @@
+import type * as typeNodemailer from 'nodemailer';
+import type Mail from 'nodemailer/lib/mailer';
+export type MailOptions = {
+    from?: Mail.Options['from'];
+    transport?: Parameters<typeof typeNodemailer.createTransport>[0];
+    apiUrl?: Parameters<typeof typeNodemailer.createTestAccount>[0];
+};
+declare let transporter: ReturnType<typeof typeNodemailer.createTransport>;
+export declare const mailInit: (nodemailer: typeof typeNodemailer, o?: MailOptions) => void;
+export declare const sendMail: (topic: string, mailOptions: Parameters<typeof transporter.sendMail>[0]) => ReturnType<typeof transporter.sendMail>;
+export {};

package/esm/mail/index.js

@@ -0,0 +1,51 @@
+import { Log, magenta } from '@kitql/helpers';
+let transporter;
+let options;
+export const mailInit = (nodemailer, o) => {
+    options = o;
+    if (o?.transport) {
+        transporter = nodemailer.createTransport(o?.transport);
+    }
+    else {
+        nodemailerHolder = nodemailer;
+        try {
+            nodemailer.createTestAccount(options?.apiUrl ?? '', (err, account) => {
+                options = { ...options, from: account.user };
+                transporter = nodemailer.createTransport({
+                    host: account.smtp.host,
+                    port: account.smtp.port,
+                    secure: account.smtp.secure,
+                    auth: {
+                        user: account.user,
+                        pass: account.pass,
+                    },
+                });
+            });
+        }
+        catch (error) {
+            log.error("Error nodemailer.createTestAccount() can't be done.");
+        }
+    }
+};
+const log = new Log('firstly | mail');
+let nodemailerHolder;
+export const sendMail = async (topic, mailOptions) => {
+    try {
+        const info = await transporter.sendMail({
+            ...mailOptions,
+            ...{ from: mailOptions.from ?? options?.from },
+        });
+        if (!options?.transport) {
+            log.info(
+            // @ts-ignore
+            `${magenta(`[${topic}]`)} - Preview URL: ${nodemailerHolder.getTestMessageUrl(info)}`);
+        }
+        else {
+            log.success(`${magenta(`[${topic}]`)} - Sent to ${mailOptions.to}`);
+        }
+        return info;
+    }
+    catch (error) {
+        log.error(`${magenta(`[${topic}]`)} - Error`, error);
+    }
+};

package/esm/theme.d.ts

@@ -0,0 +1,4 @@
+export declare const scrollbar: {
+    default: string;
+    thin: string;
+};

package/esm/theme.js

@@ -0,0 +1,4 @@
+export const scrollbar = {
+    default: 'scrollbar scrollbar-thumb-neutral-focus scrollbar-track-base-200',
+    thin: 'sm:scrollbar-thin sm:scrollbar-thumb-neutral-focus sm:scrollbar-track-base-200',
+};