@box/metadata-editor 0.45.0

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-entry/metadata-instance-entry.d.ts

@@ -0,0 +1,2 @@
+import { type MetadataInstanceEntryProps } from './types';
+export declare const MetadataInstanceEntry: ({ description, name, shouldHideEmptyValues, type, value, }: MetadataInstanceEntryProps) => import("react/jsx-runtime").JSX.Element;

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-entry/types.d.ts

@@ -0,0 +1,8 @@
+import { type MetadataFieldValue, type MetadataTemplateFieldType } from '../../../../types';
+export type MetadataInstanceEntryProps = {
+    name: string;
+    shouldHideEmptyValues: boolean;
+    type: MetadataTemplateFieldType;
+    value?: MetadataFieldValue;
+    description?: string;
+};

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-footer/messages.d.ts

@@ -0,0 +1,13 @@
+declare const messages: {
+    showEmptyValuesCTA: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    hideEmptyValuesCTA: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default messages;

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-footer/metadata-instance-footer.d.ts

@@ -0,0 +1,2 @@
+import { type MetadataInstanceFooterProps } from './types';
+export declare const MetadataInstanceFooter: ({ isAnyEmptyValueHidden, onHideEmptyValues, onShowEmptyValues, }: MetadataInstanceFooterProps) => import("react/jsx-runtime").JSX.Element;

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-footer/types.d.ts

@@ -0,0 +1,5 @@
+export type MetadataInstanceFooterProps = {
+    isAnyEmptyValueHidden: boolean;
+    onHideEmptyValues: () => void;
+    onShowEmptyValues: () => void;
+};

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-header/messages.d.ts

@@ -0,0 +1,8 @@
+declare const messages: {
+    customInstanceTitle: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default messages;

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-header/metadata-instance-header.d.ts

@@ -0,0 +1,4 @@
+import { type MetadataInstanceHeaderProps } from './types';
+export declare const autofillButtonAriaLabel = "Autofill with Box AI";
+export declare const editButtonAriaLabel = "Edit";
+export declare const MetadataInstanceHeader: ({ canEdit, isAiSuggestionsFeatureEnabled, onEdit, onAutofill, templateName, }: MetadataInstanceHeaderProps) => import("react/jsx-runtime").JSX.Element;

package/types/lib/components/metadata-instance-list/subcomponents/metadata-instance-header/types.d.ts

@@ -0,0 +1,7 @@
+export type MetadataInstanceHeaderProps = {
+    canEdit: boolean;
+    isAiSuggestionsFeatureEnabled: boolean;
+    onEdit: () => void;
+    onAutofill: () => void;
+    templateName?: string;
+};

package/types/lib/components/metadata-instance-list/types.d.ts

@@ -0,0 +1,7 @@
+import { type MetadataTemplateInstance } from '../../types';
+export type MetadataInstanceListProps = {
+    isAiSuggestionsFeatureEnabled: boolean;
+    onEdit: () => void;
+    onEditWithAutofill: () => void;
+    templateInstances: MetadataTemplateInstance[];
+};

package/types/lib/components/metadata-taxonomy-field/combobox-with-api-pagination.d.ts

@@ -0,0 +1,15 @@
+import { type ReactElement } from 'react';
+import { type PaginationQueryInput, type TaxonomyComboboxOption, type TaxonomyFetcherResponse } from './types';
+interface ComboboxWithApiPaginationProps {
+    defaultFetcher: (input: PaginationQueryInput) => Promise<TaxonomyFetcherResponse>;
+    searchFetcher?: (input: PaginationQueryInput) => Promise<TaxonomyFetcherResponse>;
+    includeTextInputOption?: boolean;
+    noResultMessage?: ReactElement | string;
+    onInputValueChange?: (inputValue: string) => void;
+    value: TaxonomyComboboxOption | TaxonomyComboboxOption[];
+    label: string;
+    loadingAriaLabel?: string;
+    multiselect?: boolean;
+}
+export declare const ComboboxWithApiPagination: (props: ComboboxWithApiPaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/lib/components/metadata-taxonomy-field/index.d.ts

@@ -0,0 +1,2 @@
+export { SingleLevelTaxonomyField } from './single-level-taxonomy-field';
+export type { SingleLevelTaxonomyFieldProps } from './types';

package/types/lib/components/metadata-taxonomy-field/messages.d.ts

@@ -0,0 +1,38 @@
+declare const messages: {
+    loadingResultsErrorAction: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadingResultsErrorMessage: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadingResultsErrorIconLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadingAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loadingMoreAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    noResults: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    clearButtonAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default messages;

package/types/lib/components/metadata-taxonomy-field/request.d.ts

@@ -0,0 +1,7 @@
+export declare enum RequestStates {
+    NOT_STARTED = "NOT_STARTED",
+    IN_PROGRESS = "IN_PROGRESS",
+    ERROR = "ERROR",
+    SUCCESS = "SUCCESS",
+    CANCELLED = "CANCELLED"
+}

package/types/lib/components/metadata-taxonomy-field/single-level-taxonomy-field.d.ts

@@ -0,0 +1,5 @@
+import { type SingleLevelTaxonomyFieldProps } from './types';
+/**
+ * The Single Level Taxonomy Field component
+ */
+export declare const SingleLevelTaxonomyField: (props: SingleLevelTaxonomyFieldProps) => import("react/jsx-runtime").JSX.Element;

package/types/lib/components/metadata-taxonomy-field/types.d.ts

@@ -0,0 +1,41 @@
+import { type ReactElement } from 'react';
+export interface PaginationQueryInput {
+    marker?: string;
+    searchInput?: string;
+    /**
+     * Abort signal that will be used to cancel the request in your fetching function
+     */
+    signal?: AbortSignal;
+}
+export interface TaxonomyResponseOption {
+    displayName: string;
+    id: string;
+    level?: number;
+}
+export interface TaxonomyResponse {
+    marker?: string;
+    options: TaxonomyResponseOption[];
+}
+export interface TaxonomyFetcherResponse {
+    marker?: string;
+    options: TaxonomyComboboxOption[];
+}
+export interface TaxonomyComboboxOption {
+    id: string;
+    value: string;
+    level?: number;
+    parentId?: string;
+    disabled?: boolean;
+}
+export interface SingleLevelTaxonomyFieldProps {
+    defaultOpen?: boolean;
+    experimentalVirtualization?: boolean;
+    multiselect?: boolean;
+    noResultMessage?: ReactElement | string;
+    portalElement?: HTMLElement | (() => HTMLElement);
+    label: string;
+    value: TaxonomyComboboxOption | TaxonomyComboboxOption[];
+    onValueChange: (value: string) => void;
+    defaultFetcher: (input: PaginationQueryInput) => Promise<TaxonomyFetcherResponse>;
+    searchFetcher: (input: PaginationQueryInput) => Promise<TaxonomyFetcherResponse>;
+}

package/types/lib/components/metadata-taxonomy-field/use-async-list.d.ts

@@ -0,0 +1,63 @@
+import { RequestStates } from './request';
+interface AsyncListOptions<T, C> {
+    /** A function that loads the data for the items in the list. */
+    load: AsyncListLoadFunction<T, C>;
+}
+type AsyncListLoadFunction<T, C> = (state: AsyncListLoadOptions<T, C>) => AsyncListStateUpdate<T, C> | Promise<AsyncListStateUpdate<T, C>>;
+interface AsyncListLoadOptions<T, C> {
+    /** The items currently in the list. */
+    items: T[];
+    /** The pagination marker returned from the last page load. */
+    marker?: C;
+    /** The current request state of the list. */
+    requestState?: RequestStates;
+    /** The current filter text used to perform server side filtering. */
+    searchInput?: string;
+    /** An abort signal used to notify the load function that the request has been aborted. */
+    signal: AbortSignal;
+}
+interface AsyncListStateUpdate<T, C> {
+    /** The new items to append to the list. */
+    items: Iterable<T>;
+    /** The pagination marker to be used for the next page load. */
+    marker?: C;
+    /** The updated filter text for the list. */
+    searchInput?: string;
+}
+declare enum ActionTypes {
+    LOAD_MORE = "LOAD_MORE",
+    RELOAD = "RELOAD",
+    SEARCH = "SEARCH",
+    SET_ERROR = "SET_ERROR",
+    SET_LOADING = "SET_LOADING"
+}
+interface AsyncListData<T> {
+    /** If loading data failed, then this contains the error that occurred. */
+    hasError: boolean;
+    /** Whether marker is expecting a next page. */
+    hasNextPage: boolean;
+    /** Whether data is populated. */
+    isEmpty: boolean;
+    /** Whether request is in a loading state. */
+    isLoading: boolean;
+    /** Wether all options are hidden and a loading indicator is all that appears */
+    isReloading: boolean;
+    /** The items in the list. */
+    items: T[];
+    /** Loads the next page of data in the list. */
+    loadMore(): void;
+    /** Reloads the data in the list. */
+    reload(): void;
+    /** Return the last action used in the reducer. */
+    requestInitiator: ActionTypes;
+    /** The current filter text. */
+    searchInput: string;
+    /** Sets the filter text. */
+    search(searchInput: string): void;
+}
+/**
+ * Manages state for an immutable async loaded list data structure, and provides convenience methods to
+ * update the data over time. Manages request states and pagination.
+ */
+export declare function useAsyncList<T, C = string>(options: AsyncListOptions<T, C>): AsyncListData<T>;
+export {};

package/types/lib/components/metadata-taxonomy-field/utils/use-intersection-observer.d.ts

@@ -0,0 +1,28 @@
+export type IntersectionObserverHookArgs = Omit<IntersectionObserverInit, 'root'>;
+export type IntersectionObserverHookRefCallbackNode = Element | null;
+export type IntersectionObserverHookRefCallback = (node: IntersectionObserverHookRefCallbackNode) => void;
+export type IntersectionObserverHookRootRefCallbackNode = IntersectionObserverInit['root'];
+export type IntersectionObserverHookRootRefCallback = (node: IntersectionObserverHookRootRefCallbackNode) => void;
+export type IntersectionObserverHookResult = [
+    IntersectionObserverHookRefCallback,
+    {
+        entry: IntersectionObserverEntry | undefined;
+        rootRef: IntersectionObserverHookRootRefCallback;
+    }
+];
+export interface CachedIntersectionObserver {
+    observe: (node: Element, callback: (entry: IntersectionObserverEntry) => void) => void;
+    unobserve: (node: Element) => void;
+}
+export declare function createObserverCache(): {
+    getObserver: ({ root, rootMargin, threshold }: IntersectionObserverInit) => CachedIntersectionObserver;
+};
+export type TrackVisibilityHookArgs = IntersectionObserverHookArgs;
+export type TrackVisibilityHookResult = [
+    IntersectionObserverHookResult[0],
+    IntersectionObserverHookResult[1] & {
+        isVisible: boolean;
+        wasEverVisible: boolean;
+    }
+];
+export declare function useTrackVisibility(args?: IntersectionObserverHookArgs): TrackVisibilityHookResult;

package/types/lib/components/unsaved-changes-modal/index.d.ts

@@ -0,0 +1 @@
+export { UnsavedChangesModal } from './unsaved-changes-modal';

package/types/lib/components/unsaved-changes-modal/messages.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    unsavedChangesModalHeader: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesModalBody: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesModalDismissCTA: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesModalSaveAndContinueCTA: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    unsavedChangesModalCloseLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default _default;

package/types/lib/components/unsaved-changes-modal/types.d.ts

@@ -0,0 +1,19 @@
+import { type ModalProps } from '@box/blueprint-web';
+export interface UnsavedChangesModalProps extends Pick<ModalProps, 'open' | 'defaultOpen'> {
+    /**
+     * Callback to be invoked when the user clicks the "Save and Continue" button.
+     *
+     * The modal will close automatically after this callback successfully completes.
+     * The callback can return either `void` for synchronous operations or a `Promise<void>` for
+     * asynchronous operations. If the callback throws an error or the returned promise rejects,
+     * the modal will not close allowing user to retry or dismiss the changes.
+     */
+    onSaveAndContinue?: () => void | Promise<void>;
+    /**
+     * Callback to be invoked when the user clicks the "Dismiss" button or the (X) button.
+     *
+     * This callback is expected to perform the dismissal action and does not need to handle
+     * closing the modal, as the modal will handle it.
+     */
+    onDismiss?: () => void;
+}

package/types/lib/components/unsaved-changes-modal/unsaved-changes-modal.d.ts

@@ -0,0 +1,2 @@
+import { type UnsavedChangesModalProps } from './types';
+export declare function UnsavedChangesModal({ onSaveAndContinue, onDismiss, defaultOpen, open: propsOpen, }: UnsavedChangesModalProps): import("react/jsx-runtime").JSX.Element;

package/types/lib/components/unsaved-changes-modal/utils.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<void>;

package/types/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const TEMPLATE_CUSTOM_PROPERTIES: "properties";

package/types/lib/defaults.d.ts

@@ -0,0 +1,13 @@
+import { type MetadataFormFieldValue } from './types';
+declare const defaultInitialValues: {
+    scope: string;
+    templateKey: string;
+    type: string;
+    id: string;
+    hidden: boolean;
+    fields: any[];
+};
+declare const defaultMetadataValueMap: {
+    [key: string]: MetadataFormFieldValue;
+};
+export { defaultInitialValues, defaultMetadataValueMap };

package/types/lib/mappers.d.ts

@@ -0,0 +1,16 @@
+import { type MetadataTemplate } from './types';
+declare const mapDataFromTemplate: (template: MetadataTemplate, withUpdateMode?: boolean) => {
+    scope: string;
+    templateKey: string;
+    type: string;
+    id: string;
+    hidden: boolean;
+    fields: import("./types").MetadataTemplateField[];
+};
+declare const mapTemplateOptionsFromTemplates: (templates: MetadataTemplate[]) => {
+    displayName: string;
+    id: string;
+    scope: string;
+    hidden: boolean;
+}[];
+export { mapDataFromTemplate, mapTemplateOptionsFromTemplates };

package/types/lib/messages.d.ts

@@ -0,0 +1,113 @@
+declare const messages: {
+    afterDateValidationError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    beforeDateValidationError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    clearSelectedDate: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    floatFieldInvalidValue: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    loading: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    multiselectPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    noTemplateAtributesError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    openCalendar: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selectDate: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selectTemplate: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selectTemplateError: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    selectValuePlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    setValuePlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    switchToNextMonth: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    switchToPreviousMonth: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorModalHeader: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorSearchInputPlaceholder: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorSearchInputIconAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorSearchInpuClearAriaLabel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorCancel: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorAdd: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+    templateSelectorClose: {
+        defaultMessage: string;
+        description: string;
+        id: string;
+    };
+};
+export default messages;

package/types/lib/metadata-editor.d.ts

@@ -0,0 +1,4 @@
+export interface MetadataEditorProps {
+}
+export declare function MetadataEditor(props: MetadataEditorProps): import("react/jsx-runtime").JSX.Element;
+export default MetadataEditor;

package/types/lib/test-utils/formik-wrapper.d.ts

@@ -0,0 +1,11 @@
+import { type FormikValues } from 'formik';
+import { type ReactNode } from 'react';
+import { type MetadataTemplate } from '../types';
+type FormikWrapperProps = {
+    children: ReactNode;
+    selectedMetadataTemplate?: MetadataTemplate;
+    onSubmit?: (values: FormikValues) => void;
+    withUpdateMode?: boolean;
+};
+export declare const FormikWrapper: (props: FormikWrapperProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/types/lib/test-utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './formik-wrapper';
+export * from './sample-data';
+export * from './test-utils';

package/types/lib/test-utils/sample-data.d.ts

@@ -0,0 +1,24 @@
+import { type MetadataTemplate, type MetadataTemplateField, type MetadataTemplateOption, type MetadataTemplateInstance } from '../types';
+declare const stringField: MetadataTemplateField;
+declare const dateField: MetadataTemplateField;
+declare const enumField: MetadataTemplateField;
+declare const floatField: MetadataTemplateField;
+declare const multiSelectField: MetadataTemplateField;
+declare const noValueField: MetadataTemplateField;
+declare const allFieldsTemplate: MetadataTemplate;
+declare const nonHiddenFieldsTemplate: MetadataTemplate;
+declare const noFieldsTemplate: MetadataTemplate;
+declare const templates: MetadataTemplate[];
+declare const customTemplate: MetadataTemplate;
+declare const templateOptions: MetadataTemplateOption[];
+declare const fields: MetadataTemplateField[];
+declare const allFieldsTemplateInstance: MetadataTemplateInstance;
+declare const templateInstanceWithoutEmptyValues: MetadataTemplateInstance;
+declare const emptyTemplateInstance: MetadataTemplateInstance;
+declare const templateInstanceWithAllFieldsEmpty: MetadataTemplateInstance;
+declare const customTemplateInstance: MetadataTemplateInstance;
+declare const customTemplateInstanceWithoutEmptyValues: MetadataTemplateInstance;
+declare const emptyCustomTemplateInstance: MetadataTemplateInstance;
+declare const customTemplateInstanceWithAllFieldsEmpty: MetadataTemplateInstance;
+declare const templateInstancesList: MetadataTemplateInstance[];
+export { allFieldsTemplate, allFieldsTemplateInstance, templateInstanceWithoutEmptyValues, emptyTemplateInstance, templateInstanceWithAllFieldsEmpty, customTemplateInstance, customTemplateInstanceWithoutEmptyValues, emptyCustomTemplateInstance, customTemplateInstanceWithAllFieldsEmpty, templateInstancesList, dateField, enumField, fields, floatField, multiSelectField, noFieldsTemplate, noValueField, nonHiddenFieldsTemplate, stringField, templateOptions, templates, customTemplate, };

package/types/lib/test-utils/test-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const updateText: (el: any, text: any) => Promise<void>;
+export declare const blur: () => Promise<void>;
+export declare const updateTextAndBlur: (el: any, text: any) => Promise<void>;

package/types/lib/types.d.ts

@@ -0,0 +1,63 @@
+export type MetadataEmptyStateProps = {
+    isBoxAiSuggestionsFeatureEnabled?: boolean;
+    isAnyEmptyValueHidden?: boolean;
+    level: 'manager' | 'file' | 'instance';
+    onShowEmptyValues?: () => void;
+};
+export type MetadataFormFieldValue = string | Array<string>;
+export type MetadataFields = Record<string, MetadataFieldValue>;
+export interface MetadataTemplateFieldOption {
+    key: string;
+    id: string;
+}
+export declare enum UpdateMode {
+    ClearAndReplace = "clearAndReplace",
+    RemoveEntered = "removeEntered",
+    ReplaceEntered = "replaceEntered",
+    Append = "append"
+}
+export interface MetadataUpdateMode {
+    /** Update mode */
+    mode: UpdateMode;
+    /** Extra data e.g. replace field value for 'replaceEntered' mode */
+    value?: MetadataFormFieldValue;
+}
+export type MetadataTemplateFieldType = 'string' | 'date' | 'enum' | 'float' | 'multiSelect';
+export type MetadataTemplateField = {
+    description?: string;
+    displayName?: string;
+    hidden: boolean;
+    id?: string;
+    key: string;
+    options?: MetadataTemplateFieldOption[];
+    type: MetadataTemplateFieldType;
+    value?: MetadataFormFieldValue;
+    updateMode?: MetadataUpdateMode;
+};
+export type MetadataTemplate = {
+    id: string;
+    type: string;
+    templateKey: string;
+    scope: string;
+    displayName?: string;
+    hidden: boolean;
+    copyInstanceOnItemCopy?: boolean;
+    fields: MetadataTemplateField[];
+};
+export type MetadataTemplateOption = {
+    displayName: string;
+    id: string;
+    hidden: boolean;
+    scope: string;
+};
+export type MetadataFieldValue = string | number | Array<string> | null;
+export type MetadataTemplateInstance = {
+    canEdit: boolean;
+    displayName?: string;
+    hidden?: boolean;
+    id: string;
+    fields: MetadataTemplateField[];
+    scope: string;
+    templateKey: string;
+    type: string;
+};