@rebasepro/common 0.0.1-canary.0

package/dist/util/collections.d.ts

@@ -0,0 +1,11 @@
+import { DefaultSelectedViewBuilder, DefaultSelectedViewParams, EntityCollection, Properties } from "@rebasepro/types";
+export declare function sortProperties<M extends Record<string, any>>(properties: Properties, propertiesOrder?: string[]): Properties;
+export declare function resolveDefaultSelectedView(defaultSelectedView: string | DefaultSelectedViewBuilder | undefined, params: DefaultSelectedViewParams): string | undefined;
+export declare function getLocalChangesBackup(collection: EntityCollection): "manual_apply" | "auto_apply";
+/**
+ * Returns the primary keys for an entity collection by inspecting the properties
+ * and finding any properties with `isId`.
+ * Fallbacks to `["id"]` if no properties are marked as `isId: true`.
+ * @param collection
+ */
+export declare function getPrimaryKeys<M extends Record<string, any>>(collection: EntityCollection<M>): Extract<keyof M, string>[];

package/dist/util/common.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ONE_OF_TYPE = "type";
+export declare const DEFAULT_ONE_OF_VALUE = "value";

package/dist/util/conditions.d.ts

@@ -0,0 +1,26 @@
+import { AuthController, ConditionContext, JsonLogicRule, Property } from "@rebasepro/types";
+/**
+ * Register custom JSON Logic operations for Rebase.
+ * Call this once at app initialization.
+ */
+export declare function registerConditionOperations(): void;
+/**
+ * Evaluate a JSON Logic rule against the given context.
+ */
+export declare function evaluateCondition(rule: JsonLogicRule, context: ConditionContext): unknown;
+/**
+ * Build a ConditionContext from the current property resolution context.
+ */
+export declare function buildConditionContext(params: {
+    propertyKey?: string;
+    values?: Record<string, unknown>;
+    previousValues?: Record<string, unknown>;
+    path: string;
+    entityId?: string;
+    index?: number;
+    authController: AuthController;
+}): ConditionContext;
+/**
+ * Apply PropertyConditions to a resolved property, evaluating all JSON Logic rules.
+ */
+export declare function applyPropertyConditions(property: Property, context: ConditionContext): Property;

package/dist/util/dates.d.ts

@@ -0,0 +1 @@
+export declare const defaultDateFormat = "MMMM dd, yyyy, HH:mm:ss";

package/dist/util/entities.d.ts

@@ -0,0 +1,28 @@
+import { DataType, Entity, EntityReference, EntityRelation, EntityStatus, EntityValues, Properties, Property } from "@rebasepro/types";
+export declare function isReadOnly(property: Property): boolean;
+export declare function isHidden(property: Property): boolean;
+export declare function isPropertyBuilder(property?: Property): boolean;
+export declare function getDefaultValuesFor<M extends Record<string, any>>(properties: Properties): Partial<EntityValues<M>>;
+export declare function getDefaultValueFor(property?: Property): {} | null | undefined;
+export declare function getDefaultValueFortype(type: DataType): {} | null;
+/**
+ * Update the automatic values in an entity before save
+ * @group Datasource
+ */
+export declare function updateDateAutoValues<M extends Record<string, any>>({ inputValues, properties, status, timestampNowValue }: {
+    inputValues: Partial<EntityValues<M>>;
+    properties: Properties;
+    status: EntityStatus;
+    timestampNowValue: unknown;
+}): EntityValues<M>;
+/**
+ * Add missing required fields, expected in the collection, to the values of an entity
+ * @param values
+ * @param properties
+ * @group Datasource
+ */
+export declare function sanitizeData<M extends Record<string, any>>(values: EntityValues<M>, properties: Properties): Record<string, unknown>;
+export declare function getReferenceFrom<M extends Record<string, any>>(entity: Entity<M>): EntityReference;
+export declare function getRelationFrom<M extends Record<string, any>>(entity: Entity<M>): EntityRelation;
+export declare function traverseValuesProperties<M extends Record<string, any>>(inputValues: Partial<EntityValues<M>>, properties: Properties, operation: (value: unknown, property: Property) => unknown): EntityValues<M> | undefined;
+export declare function traverseValueProperty(inputValue: unknown, property: Property, operation: (value: unknown, property: Property) => unknown): unknown;

package/dist/util/entity_actions.d.ts

@@ -0,0 +1,2 @@
+import { EntityAction } from "@rebasepro/types";
+export declare function mergeEntityActions(currentActions: EntityAction[], newActions: EntityAction[]): EntityAction[];

package/dist/util/enums.d.ts

@@ -0,0 +1,3 @@
+import { EnumValueConfig, EnumValues } from "@rebasepro/types";
+export declare function enumToObjectEntries(enumValues: EnumValues): EnumValueConfig[];
+export declare function getLabelOrConfigFrom(enumValues: EnumValueConfig[], key?: string | number): EnumValueConfig | undefined;

package/dist/util/fields.d.ts

@@ -0,0 +1,2 @@
+import { DefaultFieldConfig } from "@rebasepro/types";
+export declare function isDefaultFieldConfigId(id: string): id is DefaultFieldConfig;

package/dist/util/flatten_object.d.ts

@@ -0,0 +1,5 @@
+export declare function flattenObject(obj: Record<string, unknown>, parentKey?: string): {
+    [key: string]: unknown;
+};
+export type ArrayValuesCount = Record<string, number>;
+export declare function getArrayValuesCount(array: Record<string, unknown>[]): ArrayValuesCount;

package/dist/util/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashString(str: string): number;

package/dist/util/index.d.ts

@@ -0,0 +1,26 @@
+export * from "./collections";
+export * from "./common";
+export * from "./entities";
+export * from "./strings";
+export * from "./dates";
+export * from "./enums";
+export * from "./objects";
+export * from "./paths";
+export * from "./regexp";
+export * from "./navigation_utils";
+export * from "./entity_actions";
+export * from "./fields";
+export * from "./resolutions";
+export * from "./permissions";
+export * from "./plurals";
+export * from "./references";
+export * from "./flatten_object";
+export * from "./navigation_from_path";
+export * from "./parent_references_from_path";
+export * from "./builders";
+export * from "./storage";
+export * from "./arrays";
+export * from "./callbacks";
+export * from "./hash";
+export * from "./relations";
+export * from "./conditions";

package/dist/util/names.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Generates a foreign key column name from a given string, typically a collection slug or name.
+ * It converts the name to snake_case, attempts to singularize it by removing a trailing 's'
+ * (a common convention for collection names), and appends '_id'.
+ *
+ * @param name The base name to convert to a foreign key.
+ * @returns A foreign key name in the format 'singular_name_id'.
+ *
+ * @example
+ * // returns "user_id"
+ * generateForeignKeyName("users")
+ *
+ * @example
+ * // returns "post_id"
+ * generateForeignKeyName("posts")
+ *
+ * @example
+ * // returns "product_id"
+ * generateForeignKeyName("Product")
+ *
+ */
+export declare function generateForeignKeyName(name: string): string;

package/dist/util/navigation_from_path.d.ts

@@ -0,0 +1,29 @@
+import { EntityCollection, EntityCustomView } from "@rebasepro/types";
+export type NavigationViewInternal<M extends Record<string, any> = any> = NavigationViewEntityInternal<M> | NavigationViewCollectionInternal<M> | NavigationViewEntityCustomInternal<M>;
+export interface NavigationViewEntityInternal<M extends Record<string, any>> {
+    type: "entity";
+    entityId: string | number;
+    slug: string;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+export interface NavigationViewCollectionInternal<M extends Record<string, any>> {
+    type: "collection";
+    id: string;
+    slug: string;
+    path: string;
+    collection: EntityCollection<M>;
+}
+export interface NavigationViewEntityCustomInternal<M extends Record<string, any>> {
+    type: "custom_view";
+    slug: string;
+    path: string;
+    entityId: string | number;
+    view: EntityCustomView<M>;
+}
+export declare function getNavigationEntriesFromPath(props: {
+    path: string;
+    collections: EntityCollection[] | undefined;
+    currentFullPath?: string;
+    contextEntityViews?: EntityCustomView[];
+}): NavigationViewInternal[];

package/dist/util/navigation_utils.d.ts

@@ -0,0 +1,31 @@
+import { EntityCollection, CMSUrlController, SideEntityController } from "@rebasepro/types";
+export declare function removeInitialAndTrailingSlashes(s: string): string;
+export declare function removeInitialSlash(s: string): string;
+export declare function removeTrailingSlash(s: string): string;
+export declare function addInitialSlash(s: string): string;
+export declare function getLastSegment(path: string): string;
+export declare function resolveCollectionPathIds(path: string, allCollections: EntityCollection[]): string;
+/**
+ * Find the corresponding view at any depth for a given path.
+ * Note that path or segments of the paths can be collection aliases.
+ * @param slugOrPath
+ * @param collections
+ */
+export declare function getCollectionBySlugWithin(slugOrPath: string, collections: EntityCollection[]): EntityCollection | undefined;
+/**
+ * Get the subcollection combinations from a path:
+ * "sites/es/locales" => ["sites/es/locales", "sites"]
+ * @param subpaths
+ */
+export declare function getCollectionPathsCombinations(subpaths: string[]): string[];
+export declare function navigateToEntity({ openEntityMode, collection, entityId, copy, path, selectedTab, sideEntityController, onClose, navigation }: {
+    openEntityMode: "side_panel" | "full_screen";
+    collection?: EntityCollection;
+    entityId?: string | number;
+    selectedTab?: string;
+    copy?: boolean;
+    path: string;
+    sideEntityController: SideEntityController;
+    onClose?: () => void;
+    navigation: CMSUrlController;
+}): void;

package/dist/util/objects.d.ts

@@ -0,0 +1,26 @@
+/** @private is the value an empty array? */
+export declare const isEmptyArray: (value?: unknown) => boolean;
+/** @private is the given object a Function? */
+export declare const isFunction: (obj: unknown) => obj is Function;
+/** @private is the given object an integer? */
+export declare const isInteger: (obj: unknown) => boolean;
+/** @private is the given object a NaN? */
+export declare const isNaN: (obj: unknown) => boolean;
+/**
+ * Deeply get a value from an object via its path.
+ */
+export declare function getIn(obj: Record<string, unknown> | unknown[] | unknown, key: string | string[], def?: unknown, p?: number): unknown;
+export declare function setIn<T>(obj: T, path: string, value: unknown): T;
+export declare function clone<T>(value: T): T;
+export declare const pick: <T extends Record<string, unknown>>(obj: T, ...args: (keyof T)[]) => Partial<T>;
+export declare function isObject(item: unknown): item is Record<string, unknown>;
+export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
+export declare function mergeDeep<T extends Record<string, any>, U extends Record<string, any>>(target: T, source: U, ignoreUndefined?: boolean): T & U;
+export declare function getValueInPath(o: object | undefined, path: string): unknown;
+export declare function removeInPath(o: object, path: string): object | undefined;
+export declare function removeFunctions(o: unknown): unknown;
+export declare function getHashValue<T>(v: T): string | null;
+export declare function removeUndefined(value: unknown, removeEmptyStrings?: boolean): unknown;
+export declare function removeNulls(value: unknown): unknown;
+export declare function isEmptyObject(obj: object): boolean;
+export declare function removePropsIfExisting(source: Record<string, unknown> | unknown[], comparison: Record<string, unknown> | unknown[]): Record<string, unknown> | unknown[];

package/dist/util/os.d.ts

@@ -0,0 +1,2 @@
+export declare function getOS(): string;
+export declare function getAltSymbol(): "⌥" | "Alt";

package/dist/util/parent_references_from_path.d.ts

@@ -0,0 +1,6 @@
+import { EntityCollection, EntityReference } from "@rebasepro/types";
+export declare function getParentReferencesFromPath(props: {
+    path: string;
+    collections: EntityCollection[] | undefined;
+    currentFullPath?: string;
+}): EntityReference[];

package/dist/util/paths.d.ts

@@ -0,0 +1,14 @@
+export declare const COLLECTION_PATH_SEPARATOR = "::";
+/**
+ * Remove the entity ids from a given path
+ * `products/B44RG6APH/locales` => `products::locales`
+ * @param path
+ */
+export declare function stripCollectionPath(path: string): string;
+export declare function segmentsToStrippedPath(paths: string[]): string;
+/**
+ * Extract the collection path routes
+ * `products/B44RG6APH/locales` => [`products`, `locales`]
+ * @param path
+ */
+export declare function fullPathToCollectionSegments(path: string): string[];

package/dist/util/permissions.d.ts

@@ -0,0 +1,5 @@
+import { AuthController, Entity, EntityCollection, User } from "@rebasepro/types";
+export declare function canReadCollection<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>): boolean;
+export declare function canEditEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canCreateEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;
+export declare function canDeleteEntity<M extends Record<string, any>, USER extends User>(collection: EntityCollection<M>, authController: AuthController<USER>, path: string, entity: Entity<M> | null): boolean;

package/dist/util/permissions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/plurals.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns the plural of an English word.
+ *
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export declare function plural(word: string, amount?: number): string;
+/**
+ * Returns the singular of an English word.
+ *
+ * @param {string} word
+ * @param {number} [amount]
+ * @returns {string}
+ */
+export declare function singular(word: string, amount?: number): string;

package/dist/util/references.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection } from "@rebasepro/types";
+export declare function getEntityImagePreviewPropertyKey<M extends object>(collection: EntityCollection<M>): string | undefined;

package/dist/util/regexp.d.ts

@@ -0,0 +1,7 @@
+export declare function serializeRegExp(input: RegExp): string;
+/**
+ * Get a RegExp out of a serialized string
+ * @param input
+ */
+export declare function hydrateRegExp(input?: string): RegExp | undefined;
+export declare function isValidRegExp(input: string): boolean;

package/dist/util/relations.d.ts

@@ -0,0 +1,12 @@
+import { EntityCollection, Property, Relation } from "@rebasepro/types";
+export declare function sanitizeRelation(relation: Partial<Relation>, sourceCollection: EntityCollection): Relation;
+export declare function resolveCollectionRelations(collection: EntityCollection): Record<string, Relation>;
+export declare function resolvePropertyRelation({ propertyKey, property, sourceCollection }: {
+    propertyKey: string;
+    property: Property;
+    sourceCollection: EntityCollection;
+}): Relation | undefined;
+export declare function getTableName(collection: EntityCollection): string;
+export declare function getTableVarName(tableName: string): string;
+export declare function getEnumVarName(tableName: string, propName: string): string;
+export declare function getColumnName(fullColumn: string): string;

package/dist/util/resolutions.d.ts

@@ -0,0 +1,74 @@
+import { ArrayProperty, AuthController, CustomizationController, EntityAction, EntityCollection, EntityCustomView, EnumValueConfig, EnumValues, NumberProperty, Properties, Property, PropertyConfig, Relation, RelationProperty, StringProperty } from "@rebasepro/types";
+/**
+ * Resolve property builders, enums and arrays.
+ */
+export type ResolvePropertyProps<M extends Record<string, any> = any> = {
+    property: Property;
+    propertyKey?: string;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+};
+export declare function resolveProperty<M extends Record<string, any> = any>(props: ResolvePropertyProps<M>): Property | null;
+export declare function resolveRelationProperty(property: RelationProperty, relations: Relation[]): RelationProperty;
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ */
+export declare function resolvePropertyEnum(property: StringProperty | NumberProperty): StringProperty | NumberProperty;
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export declare function resolveProperties<M extends Record<string, any>>({ propertyKey, properties, ignoreMissingFields, ...props }: {
+    propertyKey?: string;
+    properties: Properties;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Properties;
+export declare function resolveArrayProperties<M>({ propertyKey, property, ignoreMissingFields, ...props }: {
+    propertyKey?: string;
+    property: ArrayProperty;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    ignoreMissingFields?: boolean;
+    authController: AuthController;
+}): Property[];
+export declare function getArrayResolvedProperties({ propertyKey, propertyValue, property, ...props }: {
+    propertyValue: unknown;
+    propertyKey?: string;
+    property: ArrayProperty;
+    ignoreMissingFields: boolean;
+    values?: object;
+    previousValues?: object;
+    path?: string;
+    entityId?: string | number;
+    index?: number;
+    propertyConfigs?: Record<string, PropertyConfig>;
+    authController: AuthController;
+}): Property[];
+export declare function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined;
+export declare function resolveEntityView(entityView: string | EntityCustomView<any>, contextEntityViews?: EntityCustomView<any>[]): EntityCustomView<any> | undefined;
+export declare function resolveEntityAction<M extends Record<string, any>>(entityAction: string | EntityAction<M>, contextEntityActions?: EntityAction<M>[]): EntityAction<M> | undefined;
+export declare function resolvedSelectedEntityView<M extends Record<string, any>>(customViews: (string | EntityCustomView<M>)[] | undefined, customizationController: CustomizationController, selectedTab?: string, canEdit?: boolean): {
+    resolvedEntityViews: EntityCustomView<M>[];
+    selectedEntityView: EntityCustomView<M> | undefined;
+    selectedSecondaryForm: EntityCustomView<M> | undefined;
+};
+export declare function getSubcollections<M extends Record<string, any> = any>(collection: EntityCollection<M>): EntityCollection<any, any>[];

package/dist/util/storage.d.ts

@@ -0,0 +1,24 @@
+import { ArrayProperty, EntityValues, StorageConfig, StringProperty, UploadedFileContext } from "@rebasepro/types";
+interface ResolveFilenameStringParams<M extends object> {
+    input: string | ((context: UploadedFileContext) => (Promise<string> | string));
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty;
+    file: File;
+    propertyKey: string;
+}
+export declare function resolveStorageFilenameString<M extends object>({ input, storage, values, entityId, path, property, file, propertyKey }: ResolveFilenameStringParams<M>): Promise<string>;
+interface ResolveStoragePathStringParams<M extends object> {
+    input: string | ((context: UploadedFileContext) => string);
+    storage: StorageConfig;
+    values: EntityValues<M>;
+    entityId?: string | number;
+    path?: string;
+    property: StringProperty | ArrayProperty;
+    file: File;
+    propertyKey: string;
+}
+export declare function resolveStoragePathString<M extends object>({ input, storage, values, entityId, path, property, file, propertyKey }: ResolveStoragePathStringParams<M>): string;
+export {};

package/dist/util/strings.d.ts

@@ -0,0 +1,7 @@
+export declare const toKebabCase: (str: string) => string;
+export declare const toSnakeCase: (str: string) => string;
+export declare function randomString(strLength?: number): string;
+export declare function randomColor(): string;
+export declare function slugify(text?: string, separator?: string, lowercase?: boolean): string;
+export declare function unslugify(slug?: string): string;
+export declare function prettifyIdentifier(input: string): string;

package/package.json

@@ -0,0 +1,118 @@
+{
+    "name": "@rebasepro/common",
+    "type": "module",
+    "version": "0.0.1-canary.0",
+    "description": "Awesome Firebase/Firestore-based headless open-source CMS",
+    "funding": {
+        "url": "https://github.com/sponsors/rebaseco"
+    },
+    "author": "Rebase",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/rebaseco/rebase.git",
+        "directory": "packages/common"
+    },
+    "main": "./dist/index.umd.js",
+    "module": "./dist/index.es.js",
+    "types": "./dist/index.d.ts",
+    "source": "src/index.ts",
+    "engines": {
+        "node": ">=14"
+    },
+    "keywords": [
+        "firebase",
+        "cms",
+        "admin",
+        "admin panel",
+        "firebase panel",
+        "firestore",
+        "headless",
+        "headless cms",
+        "content manager"
+    ],
+    "scripts": {
+        "watch": "vite build --watch",
+        "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json",
+        "prepublishOnly": "run-s build",
+        "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"
+    },
+    "exports": {
+        ".": {
+            "development": "./src/index.ts",
+            "import": "./dist/index.es.js",
+            "require": "./dist/index.umd.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./package.json": "./package.json"
+    },
+    "dependencies": {
+        "@rebasepro/types": "0.0.1-canary.0",
+        "fast-equals": "5.3.0"
+    },
+    "peerDependencies": {
+        "react": ">=19.0.0",
+        "react-dom": ">=19.0.0",
+        "react-router": "^6.28.0",
+        "react-router-dom": "^6.28.0"
+    },
+    "devDependencies": {
+        "@jest/globals": "^29.7.0",
+        "@testing-library/react": "^16.3.0",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/jest": "^29.5.14",
+        "@types/node": "^20.17.14",
+        "@types/object-hash": "^3.0.6",
+        "@types/react": "^19.0.8",
+        "@types/react-dom": "^19.0.3",
+        "@types/react-measure": "^2.0.12",
+        "@vitejs/plugin-react": "^4.3.4",
+        "babel-plugin-react-compiler": "beta",
+        "cross-env": "^7.0.3",
+        "eslint-plugin-react-compiler": "beta",
+        "jest": "^29.7.0",
+        "npm-run-all": "^4.1.5",
+        "react-router": "^7.13.1",
+        "react-router-dom": "^7.13.1",
+        "ts-jest": "^29.3.1",
+        "ts-node": "^10.9.2",
+        "tsd": "^0.31.2",
+        "typescript": "^5.8.3",
+        "vite": "^5.4.17"
+    },
+    "files": [
+        "dist",
+        "src"
+    ],
+    "gitHead": "646afae9c387c3ce02c699d98cd8c7272bdd1929",
+    "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": "node",
+        "moduleNameMapper": {
+            "\\.(css|less)$": "<rootDir>/test/__mocks__/styleMock.js"
+        }
+    }
+}