@rebasepro/app 0.17.3 → 0.18.1

package/src/util/constants.ts

@@ -1,7 +0,0 @@
-export const STUDIO_NAVIGATION_GROUPS = [
-    "Database",
-    "Compute",
-    "API",
-    "Storage",
-    "Access Control"
-];

package/src/util/createFormexStub.tsx

@@ -1,66 +0,0 @@
-import { FormexController } from "@rebasepro/forms";
-
-export function createFormexStub<T extends object>(values: T): FormexController<T> {
-    const errorMessage = "You are in a read-only context. You cannot modify the formex controller.";
-
-    return {
-        debugId: "",
-        values,
-        initialValues: values,
-        touched: {} as Record<string, boolean>,
-        dirty: false,
-        errors: {} as Record<string, string>,
-        submitCount: 0,
-        isSubmitting: false,
-        isValidating: false,
-        version: 0,
-        canUndo: false,
-        canRedo: false,
-
-        setValues: () => {
-            throw new Error(errorMessage);
-        },
-        setTouched(touched: Record<string, boolean>): void {
-            throw new Error(errorMessage);
-        },
-        setFieldValue: () => {
-            throw new Error(errorMessage);
-        },
-        setFieldTouched: () => {
-            throw new Error(errorMessage);
-        },
-        setDirty: () => {
-            throw new Error(errorMessage);
-        },
-        setSubmitCount: () => {
-            throw new Error(errorMessage);
-        },
-        setFieldError: () => {
-            throw new Error(errorMessage);
-        },
-        handleChange: () => {
-            throw new Error(errorMessage);
-        },
-        handleBlur: () => {
-            throw new Error(errorMessage);
-        },
-        handleSubmit: () => {
-            throw new Error(errorMessage);
-        },
-        validate: () => {
-            throw new Error(errorMessage);
-        },
-        resetForm: () => {
-            throw new Error(errorMessage);
-        },
-        setSubmitting: () => {
-            throw new Error(errorMessage);
-        },
-        undo: () => {
-            throw new Error(errorMessage);
-        },
-        redo: () => {
-            throw new Error(errorMessage);
-        }
-    };
-}

package/src/util/entity_cache.ts

@@ -1,242 +0,0 @@
-import { EntityReference, EntityRelation, GeoPoint, Vector } from "@rebasepro/types";
-import { isObject, isPlainObject } from "@rebasepro/utils";
-
-// Define a unique prefix for entity keys in sessionStorage to avoid key collisions
-const LOCAL_STORAGE_PREFIX = "entity_cache::";
-
-/**
- * The in-session handoff channel: an edit in flight, parked here by the layout
- * that is being replaced and picked up by the one taking over — the split's
- * "hide list", full screen's "show list", the side panel's "open full screen".
- * A record loaded from it opens *dirty*, because that is what it is for.
- *
- * Deliberately **not** hydrated from `sessionStorage`, and it is the one thing
- * here that isn't. The persisted half of this file is the local-changes backup:
- * a draft that outlives a reload, offered back through the banner or applied on
- * open, according to the collection's `localChangesBackup`. Loading those
- * drafts into this map on startup made every one of them look like a handoff —
- * the first visit to the record after a reload silently opened dirty carrying a
- * draft the user had walked away from, and the banner that exists to ask about
- * it never appeared.
- */
-const entityCache: Map<string, object> = new Map();
-
-// Check `sessionStorage` availability once during initialization
-const isSessionStorageAvailable = typeof sessionStorage !== "undefined";
-
-// Define custom replacer for JSON.stringify
-function customReplacer(this: Record<string, unknown>, key: string): unknown {
-
-    const value = this[key];
-
-    // Handle Date objects
-    if (value instanceof Date) {
-        return {
-            __type: "Date",
-            value: value.toISOString()
-        };
-    }
-
-    // Handle EntityReference
-    if (value instanceof EntityReference) {
-        return {
-            __type: "EntityReference",
-            id: value.id,
-            path: value.path,
-            driver: value.driver,
-            databaseId: value.databaseId
-        };
-    }
-
-    if (value instanceof EntityRelation) {
-        return {
-            __type: "EntityRelation",
-            id: value.id,
-            path: value.path,
-            data: value.data
-        };
-    }
-
-    // Handle GeoPoint
-    if (value instanceof GeoPoint) {
-        return {
-            __type: "GeoPoint",
-            latitude: value.latitude,
-            longitude: value.longitude
-        };
-    }
-
-    // Handle Vector
-    if (value instanceof Vector) {
-        return {
-            __type: "Vector",
-            value: value.value
-        };
-    }
-
-    return value;
-}
-
-// Define custom reviver for JSON.parse
-function customReviver(_key: string, value: unknown): unknown {
-    if (value && typeof value === "object" && "__type" in value) {
-        const record = value as Record<string, unknown>;
-        switch (record.__type) {
-            case "date":
-            case "Date":
-                return new Date(record.value as string);
-            case "reference":
-            case "EntityReference":
-                return new EntityReference({
-                    id: record.id as string,
-                    path: record.path as string,
-                    driver: record.driver as string | undefined,
-                    databaseId: record.databaseId as string | undefined
-                });
-            case "relation":
-            case "EntityRelation":
-                return new EntityRelation(record.id as string, record.path as string, record.data as Record<string, unknown> | undefined);
-            case "GeoPoint":
-                return new GeoPoint(record.latitude as number, record.longitude as number);
-            case "Vector":
-                return new Vector(record.value as number[]);
-            default:
-                return value;
-        }
-    }
-    return value;
-}
-
-/**
- * Saves data to the local-changes backup in `sessionStorage`.
- *
- * The backup only — a draft that survives a reload is not an edit in flight.
- * {@link saveEntityToMemoryCache} is the other channel; see {@link entityCache}
- * for what separates them.
- * @param path - The unique path/key for the data.
- * @param data - The data to cache and persist.
- */
-export function saveEntityToCache(path: string, data: object): void {
-    // Persist the data individually in sessionStorage
-    if (isSessionStorageAvailable) {
-        try {
-            const key = LOCAL_STORAGE_PREFIX + path;
-
-            const entityString = JSON.stringify(data, customReplacer);
-            sessionStorage.setItem(key, entityString);
-        } catch (error) {
-            console.error(
-                `Failed to save entity for path "${path}" to sessionStorage:`,
-                error
-            );
-        }
-    }
-}
-
-/**
- * Consumes a handoff. The channel is one-shot: whoever picks an edit up owns it
- * from then on, and an edit left behind here is one that reopens a record dirty
- * long after the user stopped looking at it.
- */
-export function removeEntityFromMemoryCache(path: string): void {
-    entityCache.delete(path);
-}
-
-/**
- * Parks an edit in flight for the layout about to take over. See
- * {@link entityCache}: this is the handoff, not the backup.
- */
-export function saveEntityToMemoryCache(path: string, data: object): void {
-    entityCache.set(path, data);
-}
-
-export function getEntityFromMemoryCache(path: string): object | undefined {
-    return entityCache.get(path);
-}
-
-
-/**
- * Retrieves a entity from the local-changes backup in `sessionStorage`.
- *
- * The backup only — the handoff channel is read through
- * {@link getEntityFromMemoryCache}, and the two mean different things to the
- * form that receives them.
- * @param path - The unique path/key for the entity.
- * @returns The cached entity or `undefined` if not found.
- */
-export function getEntityFromCache(path: string): object | undefined {
-
-    // If not in the cache, attempt to load it from sessionStorage
-    if (isSessionStorageAvailable) {
-        try {
-            const key = LOCAL_STORAGE_PREFIX + path;
-            const entityString = sessionStorage.getItem(key);
-            if (entityString) {
-                const entity: object = JSON.parse(entityString, customReviver);
-                return entity;
-            }
-        } catch (error) {
-            console.error(
-                `Failed to load entity for path "${path}" from sessionStorage:`,
-                error
-            );
-        }
-    }
-
-    // Entity not found
-    return undefined;
-}
-
-/**
- * Removes a entity from both the in-memory cache and `sessionStorage`.
- * @param path - The unique path/key for the entity to remove.
- */
-export function removeEntityFromCache(path: string): void {
-
-    console.debug("Removing entity from cache", path);
-
-    // Remove from the in-memory cache
-    entityCache.delete(path);
-
-    // Remove from sessionStorage
-    if (isSessionStorageAvailable) {
-        try {
-            const key = LOCAL_STORAGE_PREFIX + path;
-            sessionStorage.removeItem(key);
-        } catch (error) {
-            console.error(
-                `Failed to remove entity for path "${path}" from sessionStorage:`,
-                error
-            );
-        }
-    }
-}
-
-
-export function flattenKeys(obj: Record<string, unknown> | unknown[], prefix = "", result: string[] = []): string[] {
-
-    if (isObject(obj) || Array.isArray(obj)) {
-        const plainObject = isPlainObject(obj);
-        if (!plainObject && prefix) {
-            result.push(prefix);
-        } else {
-            const record = obj as Record<string, unknown>;
-            for (const key in record) {
-                if (Object.prototype.hasOwnProperty.call(record, key)) {
-                    const newKey = prefix
-                        ? Array.isArray(obj)
-                            ? `${prefix}[${key}]`
-                            : `${prefix}.${key}`
-                        : key;
-                    const val = record[key];
-                    if (isObject(val) || Array.isArray(val)) {
-                        flattenKeys(val as Record<string, unknown> | unknown[], newKey, result);
-                    } else {
-                        result.push(newKey);
-                    }
-                }
-            }
-        }
-    }
-    return result;
-}

package/src/util/enums.ts

@@ -1,34 +0,0 @@
-import { EnumValueConfig } from "@rebasepro/types";
-import { ChipColorScheme, getColorSchemeForKey, getColorSchemeForSeed } from "@rebasepro/ui";
-import { getLabelOrConfigFrom } from "@rebasepro/common";
-
-export function getColorScheme(enumValues: EnumValueConfig[], key: string | number): ChipColorScheme | undefined {
-    const labelOrConfig = getLabelOrConfigFrom(enumValues, key);
-    if (!labelOrConfig?.color)
-        return getColorSchemeForSeed(key.toString());
-    if (typeof labelOrConfig === "object" && "color" in labelOrConfig) {
-        if (typeof labelOrConfig.color === "string")
-            // Not a raw table lookup: a config naming a colour this build does
-            // not have still deserves a colour rather than `undefined`.
-            return getColorSchemeForKey(labelOrConfig.color);
-        if (typeof labelOrConfig.color === "object")
-            return labelOrConfig.color;
-    }
-    return undefined;
-}
-
-export function isEnumValueDisabled(labelOrConfig?: string | EnumValueConfig) {
-    return typeof labelOrConfig === "object" && (labelOrConfig as EnumValueConfig).disabled;
-}
-
-export function buildEnumLabel(
-    labelOrConfig?: string | EnumValueConfig
-): string | undefined {
-    if (labelOrConfig === undefined)
-        return undefined;
-    if (typeof labelOrConfig === "object") {
-        return labelOrConfig.label;
-    } else {
-        return labelOrConfig;
-    }
-}

package/src/util/icon_list.ts

@@ -1,22 +0,0 @@
-const iconSynonyms: Record<string, string> = {};
-import { iconKeys } from "@rebasepro/ui";
-import Fuse from "fuse.js";
-
-
-const map = iconKeys
-    .map((importName) => {
-        const iconSynonym = importName in iconSynonyms ? iconSynonyms[importName] : "";
-        return {
-            key: importName,
-            synonyms: iconSynonym
-        }
-    });
-export const iconsSearch = new Fuse(map, {
-    isCaseSensitive: false,
-    shouldSort: true,
-    ignoreLocation: true,
-    distance: 0,
-    keys: ["key", "synonyms"]
-})
-
-

package/src/util/icons.tsx

@@ -1,129 +0,0 @@
-import React from "react";
-import {
-    cls,
-    colorClassesMapping,
-    coolIconKeys,
-    IconColor,
-    iconKeys,
-    iconSize,
-    LucideIconByName
-} from "@rebasepro/ui";
-import { deepEqual as equal } from "fast-equals"
-import { hashString, slugify } from "@rebasepro/utils";
-
-// iconKeys are now PascalCase strings (e.g. "ShoppingCart", "Users")
-const iconKeysMap: Record<string, string> = iconKeys.reduce((acc: Record<string, string>, key) => {
-    // Also add lowercase versions and snake_case versions to support legacy lookups
-    const lower = key.toLowerCase();
-    const snake = key.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
-    acc[lower] = key;
-    acc[snake] = key;
-    acc[key] = key;
-    return acc;
-}, {});
-
-/**
- * Render an icon element from a string key or existing React element.
- *
- * Whether a key names an icon is decided here, against `iconKeys` — an array
- * of strings. The component behind the key is fetched by `LucideIconByName` on
- * first use: this used to index lucide's full `icons` map, which is the whole
- * library and cannot be tree-shaken.
- */
-export function getIcon(iconKey?: string | React.ReactNode,
-    className?: string,
-    color?: IconColor,
-    size?: "smallest" | "small" | "medium" | "large" | number): React.ReactElement | undefined {
-
-    if (React.isValidElement(iconKey)) {
-        return iconKey;
-    }
-
-    if (!iconKey) return undefined;
-    if (typeof iconKey === "string") {
-        const lowerKey = iconKey.toLowerCase();
-        const slugifiedKey = slugify(iconKey).replace(/-/g, "_");
-
-        const mappedKey = iconKeysMap[iconKey] || iconKeysMap[lowerKey] || iconKeysMap[slugifiedKey];
-
-        if (!mappedKey) {
-            return undefined;
-        }
-
-        const sizeInPx = typeof size === "number" ? size : iconSize[size ?? "medium"];
-        return <LucideIconByName
-            name={mappedKey}
-            size={sizeInPx}
-            className={cls(
-                color ? colorClassesMapping[color] : "",
-                "select-none shrink-0",
-                className
-            )}
-        />;
-    }
-
-    console.warn("Invalid icon key provided:", iconKey);
-    return undefined;
-}
-
-export type IconViewProps = {
-    slug: string;
-    name: string;
-    singularName?: string;
-    group?: string;
-    icon?: string | React.ReactNode;
-}
-
-export const IconForView = React.memo(
-    function IconForView({
-        collectionOrView,
-        className,
-        color,
-        size = "medium"
-    }: {
-        collectionOrView?: IconViewProps,
-        color?: IconColor,
-        className?: string,
-        size?: "smallest" | "small" | "medium" | "large" | number,
-    }): React.ReactElement {
-        if (!collectionOrView) return <></>;
-        const icon = getIcon(collectionOrView.icon, className, color, size);
-        if (collectionOrView?.icon && icon)
-            return icon;
-
-        let pathname = slugify(("singularName" in collectionOrView ? collectionOrView.singularName : undefined) ?? collectionOrView.name).replace(/-/g, "_");
-
-        let key: string | undefined;
-        if (pathname in iconKeysMap)
-            key = iconKeysMap[pathname];
-
-        if (!key) {
-            pathname = slugify(collectionOrView.slug).replace(/-/g, "_");
-            if (pathname in iconKeysMap)
-                key = iconKeysMap[pathname];
-        }
-
-        const iconsCount = coolIconKeys.length;
-
-        if (!key)
-            key = coolIconKeys[hashString(collectionOrView.slug) % iconsCount];
-
-        const sizeInPx = typeof size === "number" ? size : iconSize[size];
-        return <LucideIconByName
-            name={key}
-            size={sizeInPx}
-            className={cls(
-                color ? colorClassesMapping[color] : "",
-                "select-none shrink-0",
-                className
-            )}
-        />;
-    }, (prevProps, nextProps) => {
-        return equal(prevProps.collectionOrView?.icon, nextProps.collectionOrView?.icon) &&
-            prevProps.collectionOrView?.name === nextProps.collectionOrView?.name &&
-            prevProps.collectionOrView?.slug === nextProps.collectionOrView?.slug &&
-            prevProps.collectionOrView?.singularName === nextProps.collectionOrView?.singularName &&
-            equal(prevProps.color, nextProps.color) &&
-            prevProps.className === nextProps.className &&
-            prevProps.size === nextProps.size;
-    });

package/src/util/index.ts

@@ -1,13 +0,0 @@
-
-export * from "./icon_list";
-
-export * from "./icons";
-export * from "./createFormexStub";
-export * from "./entity_cache";
-
-export * from "./useStorageUploadController";
-
-export * from "./previews";
-export * from "./enums";
-export * from "./constants";
-export * from "./local_storage";

package/src/util/local_storage.ts

@@ -1,66 +0,0 @@
-/**
- * localStorage that tolerates not being there.
- *
- * `typeof window !== "undefined"` was the guard these call sites used, and it
- * answers the wrong question: it says "am I in a browser", not "can I read
- * storage". Three things make that distinction real rather than theoretical:
- *
- * - A browser can have storage **disabled**. Safari in private mode, a blocked
- *   third-party cookie policy, and a sandboxed iframe all give you a `window`
- *   whose `localStorage` property *throws on access* — a SecurityError raised
- *   before any method is called, which no amount of null-checking the result
- *   catches.
- * - A test environment can be **half torn down**. jsdom is disposed at the end
- *   of a file while React is still finishing a concurrent render, so `window`
- *   survives as a husk and `localStorage.getItem` is no longer a function.
- *   That is how this was found: `TypeError: localStorage.getItem is not a
- *   function`, thrown out of a render, failing a suite in which every one of
- *   709 tests passed.
- * - Server rendering has no `window` at all, which is the only case the old
- *   guard actually covered.
- *
- * Reading a UI preference is never worth a crash. Every function here fails to
- * `null` / no-op, so a user with storage switched off gets the default
- * appearance instead of a blank page.
- */
-
-/** The Storage object, or null when it is absent, blocked, or not usable. */
-function usableStorage(): Storage | null {
-    try {
-        if (typeof window === "undefined") return null;
-        const candidate = window.localStorage;
-        // Not `!= null`: a torn-down jsdom leaves an object behind whose
-        // methods are gone, which is exactly the shape that threw.
-        return typeof candidate?.getItem === "function" ? candidate : null;
-    } catch {
-        // Access itself throws when storage is blocked by policy.
-        return null;
-    }
-}
-
-/** The stored string for `key`, or null if it is unset or unreadable. */
-export function readStoredString(key: string): string | null {
-    try {
-        return usableStorage()?.getItem(key) ?? null;
-    } catch {
-        return null;
-    }
-}
-
-/** Persist `value` under `key`. A no-op when storage is unavailable. */
-export function writeStoredString(key: string, value: string): void {
-    try {
-        usableStorage()?.setItem(key, value);
-    } catch {
-        // Also the quota path: a full store throws on write but reads fine.
-    }
-}
-
-/** Remove `key`. A no-op when storage is unavailable. */
-export function removeStoredString(key: string): void {
-    try {
-        usableStorage()?.removeItem(key);
-    } catch {
-        /* nothing to undo */
-    }
-}