@firecms/core 3.0.0-alpha.70 → 3.0.0-alpha.71

package/src/util/permissions.d.ts

@@ -0,0 +1,5 @@
+import { AuthController, Entity, EntityCollection, Permissions, User } from "../types";
+export declare function resolvePermissions<M extends Record<string, any>, UserType extends User>(collection: EntityCollection<M>, authController: AuthController<UserType>, pathSegments: string[], entity: Entity<M> | null): Permissions;
+export declare function canEditEntity<M extends Record<string, any>, UserType extends User>(collection: EntityCollection<M>, authController: AuthController<UserType>, paths: string[], entity: Entity<M> | null): boolean;
+export declare function canCreateEntity<M extends Record<string, any>, UserType extends User>(collection: EntityCollection<M>, authController: AuthController<UserType>, paths: string[], entity: Entity<M> | null): boolean;
+export declare function canDeleteEntity<M extends Record<string, any>, UserType extends User>(collection: EntityCollection<M>, authController: AuthController<UserType>, paths: string[], entity: Entity<M> | null): boolean;

package/src/util/plurals.d.ts

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

package/src/util/property_utils.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import { EntityCollection, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedProperty } from "../types";
+export declare function isReferenceProperty(propertyOrBuilder: PropertyOrBuilder, fields: Record<string, PropertyConfig>): boolean | null;
+export declare function getIdIcon(size: "small" | "medium" | "large"): React.ReactNode;
+export declare function getIconForWidget(widget: PropertyConfig | undefined, size: "small" | "medium" | "large"): import("react/jsx-runtime").JSX.Element;
+export declare function getIconForProperty(property: PropertyOrBuilder | ResolvedProperty, size?: "small" | "medium" | "large", fields?: Record<string, PropertyConfig>): React.ReactNode;
+export declare function getColorForProperty(property: PropertyOrBuilder, fields: Record<string, PropertyConfig>): string;
+/**
+ * Get a property in a property tree from a path like
+ * `address.street`
+ * @param properties
+ * @param path
+ */
+export declare function getPropertyInPath<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, path: string): PropertyOrBuilder<any, M> | undefined;
+export declare function getResolvedPropertyInPath(properties: Record<string, ResolvedProperty>, path: string): ResolvedProperty | undefined;
+export declare function getBracketNotation(path: string): string;
+/**
+ * Get properties exclusively indexed by their order
+ * @param properties
+ * @param propertiesOrder
+ */
+export declare function getPropertiesWithPropertiesOrder<M extends Record<string, any>>(properties: PropertiesOrBuilders<M>, propertiesOrder?: Extract<keyof M, string>[]): PropertiesOrBuilders<M>;
+export declare function getDefaultPropertiesOrder(collection: EntityCollection<any>): string[];

package/src/util/references.d.ts

@@ -0,0 +1,2 @@
+import { EntityCollection, PropertyConfig } from "../types";
+export declare function getReferencePreviewKeys(targetCollection: EntityCollection<any>, fields: Record<string, PropertyConfig>, previewProperties?: string[], limit?: number): string[];

package/src/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/src/util/resolutions.d.ts

@@ -0,0 +1,64 @@
+import { ArrayProperty, CMSType, EntityCollection, EntityCustomView, EntityValues, EnumValueConfig, EnumValues, NumberProperty, PropertiesOrBuilders, PropertyConfig, PropertyOrBuilder, ResolvedArrayProperty, ResolvedEntityCollection, ResolvedNumberProperty, ResolvedProperties, ResolvedProperty, ResolvedStringProperty, StringProperty, UserConfigurationPersistence } from "../types";
+export declare const resolveCollection: <M extends Record<string, any>>({ collection, path, entityId, values, previousValues, userConfigPersistence, fields }: {
+    collection: EntityCollection<M, import("../types").User> | ResolvedEntityCollection<M>;
+    path: string;
+    entityId?: string | undefined;
+    values?: Partial<M> | undefined;
+    previousValues?: Partial<M> | undefined;
+    userConfigPersistence?: UserConfigurationPersistence | undefined;
+    fields?: Record<string, PropertyConfig> | undefined;
+}) => ResolvedEntityCollection<M>;
+/**
+ * Resolve property builders, enums and arrays.
+ * @param propertyOrBuilder
+ * @param propertyValue
+ * @param values
+ */
+export declare function resolveProperty<T extends CMSType = CMSType, M extends Record<string, any> = any>({ propertyOrBuilder, propertyValue, fromBuilder, ...props }: {
+    propertyKey?: string;
+    propertyOrBuilder: PropertyOrBuilder<T, M> | ResolvedProperty<T>;
+    propertyValue?: unknown;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string;
+    index?: number;
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig<any>>;
+}): ResolvedProperty<T> | null;
+export declare function resolveArrayProperty<T extends any[], M>({ propertyKey, property, propertyValue, ...props }: {
+    propertyKey?: string;
+    property: ArrayProperty<T> | ResolvedArrayProperty<T>;
+    propertyValue: any;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string;
+    index?: number;
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig>;
+}): ResolvedArrayProperty;
+/**
+ * Resolve enums and arrays for properties
+ * @param properties
+ * @param value
+ */
+export declare function resolveProperties<M extends Record<string, any>>({ properties, propertyValue, ...props }: {
+    properties: PropertiesOrBuilders<M>;
+    propertyValue: unknown;
+    values?: Partial<M>;
+    previousValues?: Partial<M>;
+    path?: string;
+    entityId?: string;
+    index?: number;
+    fromBuilder?: boolean;
+    fields?: Record<string, PropertyConfig>;
+}): ResolvedProperties<M>;
+/**
+ * Resolve enum aliases for a string or number property
+ * @param property
+ * @param fromBuilder
+ */
+export declare function resolvePropertyEnum(property: StringProperty | NumberProperty, fromBuilder?: boolean): ResolvedStringProperty | ResolvedNumberProperty;
+export declare function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined;
+export declare function resolveEntityView(entityView: string | EntityCustomView<any>, contextEntityViews?: EntityCustomView<any>[]): EntityCustomView<any> | undefined;

package/src/util/storage.d.ts

@@ -0,0 +1,3 @@
+import { EntityValues, ResolvedArrayProperty, ResolvedStringProperty, StorageConfig, UploadedFileContext } from "../types";
+export declare function resolveFilenameString<M extends object>(input: string | ((context: UploadedFileContext) => Promise<string> | string), storage: StorageConfig, values: EntityValues<M>, entityId: string, path: string, property: ResolvedStringProperty | ResolvedArrayProperty<string[]>, file: File, propertyKey: string): Promise<string>;
+export declare function resolveStoragePathString<M extends object>(input: string | ((context: UploadedFileContext) => string), storage: StorageConfig, values: EntityValues<M>, entityId: string, path: string, property: ResolvedStringProperty | ResolvedArrayProperty<string[]>, file: File, propertyKey: string): string;

package/src/util/strings.d.ts

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

package/src/util/useDebounce.d.ts

@@ -0,0 +1 @@
+export declare function useDebounce<T>(value: T, callback: () => void, immediate: boolean, timeoutMs?: number): void;

package/src/util/useStorageUploadController.d.ts

@@ -0,0 +1,36 @@
+import { EntityValues, ResolvedArrayProperty, ResolvedStringProperty, StorageConfig, StorageSource } from "../types";
+import { PreviewSize } from "../preview";
+/**
+ * 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?: any;
+    size: PreviewSize;
+}
+export declare function useStorageUploadController<M extends object>({ entityId, entityValues, path, value, property, propertyKey, storageSource, disabled, onChange }: {
+    entityId: string;
+    entityValues: EntityValues<M>;
+    value: string | string[] | null;
+    path: string;
+    propertyKey: string;
+    property: ResolvedStringProperty | ResolvedArrayProperty<string[]>;
+    storageSource: StorageSource;
+    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?: any) => Promise<void>;
+    onFilesAdded: (acceptedFiles: File[]) => Promise<void>;
+    multipleFilesSupported: boolean;
+};