@rebasepro/app 0.0.1-canary.4829d6e

package/dist/internal/common.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Layout width primitives used by the framework's own side-panel and form
+ * dialog sizing logic.
+ *
+ * @internal Not part of the stable public API — exported only because
+ * `@rebasepro/admin` and `@rebasepro/studio` need them to compute the same
+ * dialog widths as the framework. Do not depend on these for app code; they
+ * may change shape or be removed without a major version bump.
+ */
+export declare const CONTAINER_FULL_WIDTH = "100vw";
+/** @internal See {@link CONTAINER_FULL_WIDTH}. */
+export declare const ADDITIONAL_TAB_WIDTH = "55vw";
+/** @internal See {@link CONTAINER_FULL_WIDTH}. */
+export declare const FORM_CONTAINER_WIDTH = "768px";

package/dist/internal/useRestoreScroll.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+/**
+ * Restores per-route scroll position on a scrollable container, keyed by
+ * router location. Used by the framework's own home page implementations.
+ *
+ * @internal Not part of the stable public API — exported only because
+ * `@rebasepro/admin` and `@rebasepro/studio` reuse it in their home page
+ * components. Its behavior (module-level scroll cache, router coupling) is
+ * an implementation detail and may change without a major version bump.
+ */
+export declare function useRestoreScroll(): {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    scroll: number;
+    direction: "up" | "down";
+};

package/dist/locales/de.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const de: RebaseTranslations;

package/dist/locales/en.d.ts

@@ -0,0 +1,10 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * English baseline translations for @rebasepro/app.
+ *
+ * This is the single source of truth for all default UI strings.
+ * Override any key via the `translations` prop on Rebase entry-point components.
+ *
+ * @group Core
+ */
+export declare const en: RebaseTranslations;

package/dist/locales/es.d.ts

@@ -0,0 +1,10 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * Spanish baseline translations for @rebasepro/app.
+ *
+ * This is the single source of truth for all default UI strings in Spanish.
+ * Override any key via the `translations` prop on Rebase entry-point components.
+ *
+ * @group Core
+ */
+export declare const es: RebaseTranslations;

package/dist/locales/fr.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const fr: RebaseTranslations;

package/dist/locales/hi.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const hi: RebaseTranslations;

package/dist/locales/it.d.ts

@@ -0,0 +1,2 @@
+import { RebaseTranslations } from "@rebasepro/types";
+export declare const it: RebaseTranslations;

package/dist/locales/pt.d.ts

@@ -0,0 +1,7 @@
+import { RebaseTranslations } from "@rebasepro/types";
+/**
+ * Portuguese (pt) translations for @rebasepro/app.
+ *
+ * @group Core
+ */
+export declare const pt: RebaseTranslations;

package/dist/util/constants.d.ts

@@ -0,0 +1 @@
+export declare const STUDIO_NAVIGATION_GROUPS: string[];

package/dist/util/createFormexStub.d.ts

@@ -0,0 +1,2 @@
+import { FormexController } from "@rebasepro/forms";
+export declare function createFormexStub<T extends object>(values: T): FormexController<T>;

package/dist/util/entity_cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Saves data to the in-memory cache and persists it individually in `sessionStorage`.
+ * @param path - The unique path/key for the data.
+ * @param data - The data to cache and persist.
+ */
+export declare function saveEntityToCache(path: string, data: object): void;
+export declare function removeEntityFromMemoryCache(path: string): void;
+export declare function saveEntityToMemoryCache(path: string, data: object): void;
+export declare function getEntityFromMemoryCache(path: string): object | undefined;
+/**
+ * Retrieves a entity from the in-memory cache or `sessionStorage`.
+ * If the entity is not in the cache but exists in `sessionStorage`, it loads it into the cache.
+ * @param path - The unique path/key for the entity.
+ * @returns The cached entity or `undefined` if not found.
+ */
+export declare function getEntityFromCache(path: string): object | undefined;
+/**
+ * Removes a entity from both the in-memory cache and `sessionStorage`.
+ * @param path - The unique path/key for the entity to remove.
+ */
+export declare function removeEntityFromCache(path: string): void;
+export declare function flattenKeys(obj: Record<string, unknown> | unknown[], prefix?: string, result?: string[]): string[];

package/dist/util/enums.d.ts

@@ -0,0 +1,5 @@
+import { EnumValueConfig } from "@rebasepro/types";
+import { ChipColorScheme } from "@rebasepro/ui";
+export declare function getColorScheme(enumValues: EnumValueConfig[], key: string | number): ChipColorScheme | undefined;
+export declare function isEnumValueDisabled(labelOrConfig?: string | EnumValueConfig): boolean | undefined;
+export declare function buildEnumLabel(labelOrConfig?: string | EnumValueConfig): string | undefined;

package/dist/util/icon_list.d.ts

@@ -0,0 +1,5 @@
+import Fuse from "fuse.js";
+export declare const iconsSearch: Fuse<{
+    key: string;
+    synonyms: string;
+}>;

package/dist/util/icons.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import { IconColor } from "@rebasepro/ui";
+/**
+ * Render an icon element from a string key or existing React element.
+ * This resolves the icon from the lucide-react icons map directly.
+ */
+export declare function getIcon(iconKey?: string | React.ReactNode, className?: string, color?: IconColor, size?: "smallest" | "small" | "medium" | "large" | number): React.ReactElement | undefined;
+export type IconViewProps = {
+    slug: string;
+    name: string;
+    singularName?: string;
+    group?: string;
+    icon?: string | React.ReactNode;
+};
+export declare const IconForView: React.MemoExoticComponent<({ collectionOrView, className, color, size }: {
+    collectionOrView?: IconViewProps;
+    color?: IconColor;
+    className?: string;
+    size?: "smallest" | "small" | "medium" | "large" | number;
+}) => React.ReactElement>;

package/dist/util/index.d.ts

@@ -0,0 +1,8 @@
+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";

package/dist/util/previews.d.ts

@@ -0,0 +1,4 @@
+import type { CollectionConfig, PropertyConfig } from "@rebasepro/types";
+import { AuthController } from "@rebasepro/types";
+export declare function getEntityPreviewKeys(authController: AuthController, targetCollection: CollectionConfig<any>, fields: Record<string, PropertyConfig>, previewProperties?: string[], limit?: number): string[];
+export declare function getEntityTitlePropertyKey<M extends Record<string, any>>(collection: CollectionConfig<M>, propertyConfigs: Record<string, PropertyConfig>): string | undefined;

package/dist/util/useStorageUploadController.d.ts

@@ -0,0 +1,44 @@
+import type { ArrayProperty, StringProperty } from "@rebasepro/types";
+import { EntityValues, StorageConfig, StorageSource, StorageSourceRegistry } from "@rebasepro/types";
+export type StorageFieldSize = "smallest" | "small" | "medium" | "large" | number;
+/**
+ * Internal representation of an item in the storage
+ * It can have two states, having a storagePathOrDownloadUrl set,
+ * which means the file has been uploaded, and it is rendered as a preview
+ * Or have a pending file being uploaded.
+ */
+export interface StorageFieldItem {
+    id: number;
+    storagePathOrDownloadUrl?: string;
+    file?: File;
+    fileName?: string;
+    metadata?: Record<string, unknown>;
+    size: StorageFieldSize;
+}
+export declare function useStorageUploadController<M extends Record<string, unknown>>({ entityId, entityValues, path, value, property, propertyKey, storageSource, storageSourceRegistry, disabled, onChange }: {
+    entityId?: string | number;
+    entityValues: EntityValues<M>;
+    value: string | string[] | null;
+    path?: string;
+    propertyKey: string;
+    property: StringProperty | ArrayProperty | StringProperty | ArrayProperty;
+    storageSource: StorageSource;
+    /** Optional explicit registry. When omitted, the hook reads from the
+     *  `StorageSourcesContext` provided by `<Rebase storageSources={...}>`. */
+    storageSourceRegistry?: StorageSourceRegistry;
+    disabled: boolean;
+    onChange: (value: string | string[] | null) => void;
+}): {
+    internalValue: StorageFieldItem[];
+    setInternalValue: import("react").Dispatch<import("react").SetStateAction<StorageFieldItem[]>>;
+    storage: StorageConfig;
+    fileNameBuilder: (file: File) => Promise<string>;
+    storagePathBuilder: (file: File) => string;
+    onFileUploadComplete: (uploadedPath: string, entry: StorageFieldItem, metadata?: Record<string, unknown>, uploadedUrl?: string) => Promise<void>;
+    onFileUploadError: (entry: StorageFieldItem) => void;
+    onFilesAdded: (acceptedFiles: File[]) => Promise<void>;
+    multipleFilesSupported: boolean;
+    /** The resolved StorageSource for this property — may differ from the
+     *  default context source when `StorageConfig.storageSource` is set. */
+    resolvedStorageSource: StorageSource;
+};

package/dist/vitePlugin.d.ts

@@ -0,0 +1,60 @@
+import MagicString from "magic-string";
+export interface RebaseCollectionsPluginOptions {
+    /**
+     * The path to the collections directory containing the schema definitions.
+     * Use a relative or absolute path from the root of your frontend workspace.
+     */
+    collectionsDir: string;
+}
+/**
+ * Perform the AST-based transform on `code`.
+ *
+ * Parses the source with the TypeScript compiler API, walks the tree for
+ * `PropertyAssignment` nodes whose name matches one of `LAZY_COMPONENT_KEYS`
+ * and whose initializer is a string literal starting with `./` or `../`.
+ *
+ * Each match is rewritten in-place via `magic-string` so that source-maps
+ * remain correct.
+ *
+ * @returns `{ code, map }` if at least one replacement was made; `null` otherwise.
+ */
+export declare function transformCollectionSource(code: string, id: string): {
+    code: string;
+    map: ReturnType<MagicString["generateMap"]>;
+} | null;
+/**
+ * A Vite plugin that dynamically loads and automatically wires Rebase collections.
+ *
+ * It provides two capabilities:
+ * 1. A **virtual module** `"virtual:rebase-collections"` that statically exports
+ *    the resolved collections array.
+ * 2. A **transform hook** that converts string-based component references
+ *    (e.g. `Field: "../../components/MyField"`) into `LazyComponentRef` objects
+ *    (`{ __rebaseLazy: true, load: () => import(...) }`), enabling code-splitting
+ *    and preventing the backend from loading React-dependent modules.
+ */
+export declare function rebaseCollectionsPlugin(options: RebaseCollectionsPluginOptions): {
+    name: string;
+    configResolved(config: {
+        root: string;
+    }): void;
+    resolveId(id: string): string | null;
+    load(id: string): string | null;
+    /**
+     * Transform collection files to convert string component references
+     * into lazy-loading `LazyComponentRef` objects.
+     *
+     * Example transform:
+     * ```
+     * // Input
+     * Field: "../../frontend/src/components/MyField"
+     *
+     * // Output
+     * Field: { __rebaseLazy: true, load: () => import("../../frontend/src/components/MyField") }
+     * ```
+     */
+    transform(code: string, id: string): {
+        code: string;
+        map: ReturnType<MagicString["generateMap"]>;
+    } | null;
+};

package/dist/vitePlugin.js

@@ -0,0 +1,113 @@
+import path from "path";
+import ts from "typescript";
+import MagicString from "magic-string";
+const LAZY_COMPONENT_KEYS = /* @__PURE__ */ new Set(["Field", "Preview", "Builder"]);
+function walkAST(node, visitor) {
+  visitor(node);
+  node.forEachChild((child) => walkAST(child, visitor));
+}
+function getPropertyName(node) {
+  const { name } = node;
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isStringLiteral(name)) return name.text;
+  return void 0;
+}
+function transformCollectionSource(code, id) {
+  const sourceFile = ts.createSourceFile(
+    id,
+    code,
+    ts.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    ts.ScriptKind.TSX
+  );
+  const ms = new MagicString(code);
+  let replaced = false;
+  walkAST(sourceFile, (node) => {
+    if (!ts.isPropertyAssignment(node)) return;
+    const propName = getPropertyName(node);
+    if (!propName || !LAZY_COMPONENT_KEYS.has(propName)) return;
+    const init = node.initializer;
+    if (!ts.isStringLiteral(init)) return;
+    const importPath = init.text;
+    if (!importPath.startsWith("./") && !importPath.startsWith("../")) return;
+    const initStart = init.getStart(sourceFile);
+    const quoteChar = code.charAt(initStart);
+    const replacement = `{ __rebaseLazy: true, load: () => import(${quoteChar}${importPath}${quoteChar}) }`;
+    ms.overwrite(initStart, init.getEnd(), replacement);
+    replaced = true;
+  });
+  if (!replaced) return null;
+  return {
+    code: ms.toString(),
+    map: ms.generateMap({ hires: true })
+  };
+}
+function rebaseCollectionsPlugin(options) {
+  const virtualModuleId = "virtual:rebase-collections";
+  const resolvedVirtualModuleId = "\0" + virtualModuleId;
+  let resolvedCollectionsDir;
+  return {
+    name: "rebase-collections-plugin",
+    configResolved(config) {
+      resolvedCollectionsDir = path.isAbsolute(options.collectionsDir) ? options.collectionsDir : path.resolve(config.root, options.collectionsDir);
+    },
+    resolveId(id) {
+      if (id === virtualModuleId) {
+        return resolvedVirtualModuleId;
+      }
+      return null;
+    },
+    load(id) {
+      if (id === resolvedVirtualModuleId) {
+        const globPath = options.collectionsDir.startsWith("/") ? `${options.collectionsDir}/*.ts` : `/${options.collectionsDir}/*.ts`;
+        return `
+                    // GENERATED BY @rebasepro/app Vite Plugin
+                    const collectionModules = import.meta.glob('${globPath}', { eager: true });
+
+                    // index exports the directory's defaults, not a collection \u2014
+                    // it has no default export, so it drops out of the list below.
+                    // Mirrors loadCollectionsFromDirectory in @rebasepro/server:
+                    // the admin would otherwise show a collection as having no
+                    // rules while the database enforces the inherited ones.
+                    const indexEntry = Object.entries(collectionModules)
+                        .find(([path]) => path.endsWith("/index.ts") || path.endsWith("/index.js"));
+                    const defaultSecurityRules = indexEntry?.[1]?.defaultSecurityRules;
+
+                    export const collections = Object.values(collectionModules)
+                        .map((module) => module.default)
+                        .filter(Boolean)
+                        .map((collection) =>
+                            defaultSecurityRules?.length && !collection.securityRules?.length
+                                ? { ...collection, securityRules: defaultSecurityRules }
+                                : collection
+                        );
+                `;
+      }
+      return null;
+    },
+    /**
+     * Transform collection files to convert string component references
+     * into lazy-loading `LazyComponentRef` objects.
+     *
+     * Example transform:
+     * ```
+     * // Input
+     * Field: "../../frontend/src/components/MyField"
+     *
+     * // Output
+     * Field: { __rebaseLazy: true, load: () => import("../../frontend/src/components/MyField") }
+     * ```
+     */
+    transform(code, id) {
+      if (!resolvedCollectionsDir) return null;
+      if (!id.startsWith(resolvedCollectionsDir)) return null;
+      if (!/\.tsx?$/.test(id)) return null;
+      return transformCollectionSource(code, id);
+    }
+  };
+}
+export {
+  rebaseCollectionsPlugin,
+  transformCollectionSource
+};

package/package.json

@@ -0,0 +1,145 @@
+{
+  "name": "@rebasepro/app",
+  "type": "module",
+  "version": "0.0.1-canary.4829d6e",
+  "description": "Rebase core — framework-agnostic runtime for data-driven admin panels",
+  "funding": {
+    "url": "https://github.com/sponsors/rebaseco"
+  },
+  "author": "Rebase",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rebasepro/rebase.git",
+    "directory": "packages/app"
+  },
+  "main": "./dist/index.umd.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "source": "src/index.ts",
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": [
+    "rebase",
+    "cms",
+    "admin",
+    "admin panel",
+    "typescript",
+    "headless",
+    "headless cms",
+    "content manager"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./dist/index.es.js",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.umd.js"
+    },
+    "./vitePlugin": {
+      "types": "./dist/vitePlugin.d.ts",
+      "development": "./dist/vitePlugin.js",
+      "import": "./dist/vitePlugin.js",
+      "require": "./dist/vitePlugin.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "compressorjs": "^1.3.0",
+    "fast-equals": "6.0.0",
+    "fuse.js": "^7.4.2",
+    "i18next": "^26.3.1",
+    "lucide-react": "1.18.0",
+    "magic-string": "^0.30.0",
+    "notistack": "^3.0.2",
+    "react-i18next": "^17.0.8",
+    "@rebasepro/common": "0.0.1-canary.4829d6e",
+    "@rebasepro/forms": "0.0.1-canary.4829d6e",
+    "@rebasepro/types": "0.0.1-canary.4829d6e",
+    "@rebasepro/ui": "0.0.1-canary.4829d6e",
+    "@rebasepro/utils": "0.0.1-canary.4829d6e"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0",
+    "react-router": "^7.0.0",
+    "react-router-dom": "^7.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^30.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.3",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@types/react-measure": "^2.0.12",
+    "@vitejs/plugin-react": "^6.0.2",
+    "babel-plugin-react-compiler": "beta",
+    "cross-env": "^10.1.0",
+    "esbuild": "^0.28.1",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
+    "react-router-dom": "^7.17.0",
+    "ts-jest": "^29.4.11",
+    "tsd": "^0.33.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
+  "publishConfig": {
+    "access": "public"
+  },
+  "eslintConfig": {
+    "extends": [
+      "react-app",
+      "react-app/jest"
+    ]
+  },
+  "jest": {
+    "transform": {
+      "^.+\\.tsx?$": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ],
+    "testEnvironment": "jsdom",
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/src/components/",
+      "objects.test.ts",
+      "navigation.test.ts",
+      "resolutions.test.ts"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/setupTests.ts"
+    ],
+    "moduleNameMapper": {
+      "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js",
+      "^@rebasepro/ui$": "<rootDir>/../ui/src/index.ts",
+      "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
+      "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
+      "^@rebasepro/forms$": "<rootDir>/../forms/src/index.ts"
+    }
+  },
+  "scripts": {
+    "watch": "vite build --watch",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && pnpm exec esbuild src/vitePlugin.ts --platform=node --format=esm --outfile=dist/vitePlugin.js",
+    "test:lint": "eslint \"src/**\" --quiet",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f",
+    "generateIcons": "ts-node --esm src/icons/generateIcons.ts"
+  }
+}