@payloadcms/ui 3.0.0-beta.11 → 3.0.0-beta.111

package/dist/elements/BulkUpload/FileSidebar/index.scss

@@ -0,0 +1,277 @@
+@import '../../../scss/styles.scss';
+
+.file-selections {
+  --file-gutter-h: calc(var(--gutter-h) / 4);
+  border-right: 1px solid var(--theme-border-color);
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  width: 300px;
+  overflow: auto;
+  max-height: 100%;
+
+  &__header {
+    position: sticky;
+    top: 0;
+    margin-top: var(--base);
+    z-index: 1;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    width: 100%;
+    background: var(--theme-bg);
+    flex-wrap: wrap;
+
+    p {
+      margin: 0;
+    }
+  }
+
+  &__headerTopRow {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: var(--base);
+    width: 100%;
+    padding-block: var(--base);
+    padding-inline: var(--file-gutter-h);
+  }
+
+  &__header__text {
+    display: flex;
+    flex-direction: column;
+
+    .error-pill {
+      align-self: flex-start;
+    }
+  }
+
+  &__filesContainer {
+    display: flex;
+    flex-direction: column;
+    gap: calc(var(--base) / 4);
+    margin-top: calc(var(--base) / 2);
+    width: 100%;
+    padding-inline: var(--file-gutter-h);
+
+    .shimmer-effect {
+      border-radius: var(--style-radius-m);
+    }
+  }
+
+  &__fileRowContainer {
+    --rowPadding: calc(var(--base) / 4);
+    position: relative;
+    &:last-child {
+      margin-bottom: calc(var(--base) / 4);
+    }
+  }
+
+  &__fileRow {
+    @include btn-reset;
+    display: flex;
+    padding: var(--rowPadding);
+    align-items: center;
+    gap: calc(var(--base) / 2);
+    border-radius: var(--style-radius-m);
+    max-width: 100%;
+    cursor: pointer;
+    width: 100%;
+
+    &:hover {
+      background-color: var(--theme-elevation-100);
+    }
+
+    .thumbnail {
+      width: base(1.2);
+      height: base(1.2);
+      flex-shrink: 0;
+      object-fit: cover;
+      border-radius: var(--style-radius-s);
+    }
+
+    p {
+      margin: 0;
+    }
+  }
+
+  &__fileDetails {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+
+  &__fileRowContainer--active {
+    .file-selections__fileRow {
+      background-color: var(--theme-elevation-100);
+    }
+
+    .file-selections__remove {
+      .icon--x {
+        opacity: 1;
+      }
+    }
+  }
+
+  &__fileRowContainer--error {
+    .file-selections__fileRow {
+      background-color: var(--theme-error-100);
+    }
+
+    &.file-selections__fileRowContainer--active .file-selections__fileRow,
+    .file-selections__fileRow:hover {
+      background-color: var(--theme-error-200);
+    }
+
+    .file-selections__remove--overlay:hover {
+      background-color: var(--theme-error-50);
+
+      .icon--x {
+        opacity: 1;
+      }
+    }
+  }
+
+  &__errorCount {
+    margin-left: auto;
+    position: absolute;
+    transform: translate(50%, -50%);
+    top: 0;
+    right: 0;
+  }
+
+  &__fileName {
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  &__fileSize {
+    font-size: calc(var(--base) / 2);
+    color: var(--theme-elvation-400);
+    flex-shrink: 0;
+  }
+
+  &__remove {
+    @include btn-reset;
+    margin: 0;
+    margin-left: auto;
+
+    .icon--x {
+      opacity: 0.75;
+    }
+  }
+
+  &__remove--underlay {
+    pointer-events: none;
+    opacity: 0;
+  }
+
+  &__remove--overlay {
+    position: absolute;
+    transform: translateY(-50%);
+    top: 50%;
+    bottom: 50%;
+    right: var(--rowPadding);
+    height: 20px;
+    border-radius: var(--style-radius-m);
+    cursor: pointer;
+
+    &:hover {
+      background-color: var(--theme-elevation-200);
+    }
+  }
+
+  &__header__actions {
+    display: flex;
+    gap: var(--base);
+  }
+
+  &__toggler {
+    display: none;
+    margin: 0;
+    padding-block: 0;
+  }
+
+  &__header__mobileDocActions {
+    display: none;
+  }
+
+  &__animateWrapper {
+    overflow: auto;
+  }
+
+  &__mobileBlur {
+    @include blur-bg;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    transition: opacity 100ms cubic-bezier(0, 0.2, 0.2, 1);
+  }
+
+  &__showingFiles {
+    .file-selections__mobileBlur {
+      opacity: 1;
+    }
+  }
+
+  @include mid-break {
+    --file-gutter-h: var(--gutter-h);
+    flex-direction: column-reverse;
+    width: 100%;
+    position: sticky;
+    bottom: 0;
+    flex-shrink: 0;
+
+    &__showingFiles {
+      z-index: 2;
+    }
+
+    &__filesContainer {
+      @include blur-bg;
+    }
+
+    &__fileRowContainer {
+      z-index: 1;
+    }
+
+    &__header {
+      margin-top: 0;
+    }
+
+    &__headerTopRow {
+      border-top: 1px solid var(--theme-border-color);
+      padding-block: calc(var(--base) * 0.8);
+    }
+
+    &__header__mobileDocActions {
+      position: relative;
+      display: flex;
+      width: 100%;
+      padding-block: calc(var(--base) * 0.8);
+      padding-inline: var(--file-gutter-h);
+      border-top: 1px solid var(--theme-border-color);
+
+      > div {
+        display: flex;
+        justify-content: flex-end;
+        width: 100%;
+        button {
+          flex: 0.5;
+        }
+      }
+    }
+
+    &__toggler {
+      padding-right: 0;
+      display: block;
+    }
+
+    .btn {
+      margin: 0;
+    }
+  }
+}

package/dist/elements/BulkUpload/FormsManager/createFormData.d.ts

@@ -0,0 +1,3 @@
+import type { FormState } from 'payload';
+export declare function createFormData(formState?: FormState, overrides?: Record<string, any>): FormData;
+//# sourceMappingURL=createFormData.d.ts.map

package/dist/elements/BulkUpload/FormsManager/createFormData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormData.d.ts","sourceRoot":"","sources":["../../../../src/elements/BulkUpload/FormsManager/createFormData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAKxC,wBAAgB,cAAc,CAAC,SAAS,GAAE,SAAc,EAAE,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,YAmB5F"}

package/dist/elements/BulkUpload/FormsManager/createFormData.js

@@ -0,0 +1,22 @@
+import { serialize } from 'object-to-formdata';
+import { reduceFieldsToValues } from 'payload/shared';
+export function createFormData(formState = {}, overrides = {}) {
+  const data = reduceFieldsToValues(formState, true);
+  const file = data?.file;
+  if (file) {
+    delete data.file;
+  }
+  const dataWithOverrides = {
+    ...data,
+    ...overrides
+  };
+  const dataToSerialize = {
+    _payload: JSON.stringify(dataWithOverrides),
+    file
+  };
+  return serialize(dataToSerialize, {
+    indices: true,
+    nullsAsUndefineds: false
+  });
+}
+//# sourceMappingURL=createFormData.js.map

package/dist/elements/BulkUpload/FormsManager/createFormData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createFormData.js","names":["serialize","reduceFieldsToValues","createFormData","formState","overrides","data","file","dataWithOverrides","dataToSerialize","_payload","JSON","stringify","indices","nullsAsUndefineds"],"sources":["../../../../src/elements/BulkUpload/FormsManager/createFormData.ts"],"sourcesContent":["import type { FormState } from 'payload'\n\nimport { serialize } from 'object-to-formdata'\nimport { reduceFieldsToValues } from 'payload/shared'\n\nexport function createFormData(formState: FormState = {}, overrides: Record<string, any> = {}) {\n  const data = reduceFieldsToValues(formState, true)\n  const file = data?.file\n\n  if (file) {\n    delete data.file\n  }\n\n  const dataWithOverrides = {\n    ...data,\n    ...overrides,\n  }\n\n  const dataToSerialize = {\n    _payload: JSON.stringify(dataWithOverrides),\n    file,\n  }\n\n  return serialize(dataToSerialize, { indices: true, nullsAsUndefineds: false })\n}\n"],"mappings":"AAEA,SAASA,SAAS,QAAQ;AAC1B,SAASC,oBAAoB,QAAQ;AAErC,OAAO,SAASC,eAAeC,SAAA,GAAuB,CAAC,CAAC,EAAEC,SAAA,GAAiC,CAAC,CAAC;EAC3F,MAAMC,IAAA,GAAOJ,oBAAA,CAAqBE,SAAA,EAAW;EAC7C,MAAMG,IAAA,GAAOD,IAAA,EAAMC,IAAA;EAEnB,IAAIA,IAAA,EAAM;IACR,OAAOD,IAAA,CAAKC,IAAI;EAClB;EAEA,MAAMC,iBAAA,GAAoB;IACxB,GAAGF,IAAI;IACP,GAAGD;EACL;EAEA,MAAMI,eAAA,GAAkB;IACtBC,QAAA,EAAUC,IAAA,CAAKC,SAAS,CAACJ,iBAAA;IACzBD;EACF;EAEA,OAAON,SAAA,CAAUQ,eAAA,EAAiB;IAAEI,OAAA,EAAS;IAAMC,iBAAA,EAAmB;EAAM;AAC9E","ignoreList":[]}

package/dist/elements/BulkUpload/FormsManager/index.d.ts

@@ -0,0 +1,32 @@
+import type { Data, DocumentPermissions } from 'payload';
+import React from 'react';
+import type { State } from './reducer.js';
+type FormsManagerContext = {
+    readonly activeIndex: State['activeIndex'];
+    readonly addFiles: (filelist: FileList) => Promise<void>;
+    readonly collectionSlug: string;
+    readonly docPermissions?: DocumentPermissions;
+    readonly forms: State['forms'];
+    getFormDataRef: React.RefObject<() => Data>;
+    readonly hasPublishPermission: boolean;
+    readonly hasSavePermission: boolean;
+    readonly hasSubmitted: boolean;
+    readonly isInitializing: boolean;
+    readonly removeFile: (index: number) => void;
+    readonly saveAllDocs: ({ overrides }?: {
+        overrides?: Record<string, unknown>;
+    }) => Promise<void>;
+    readonly setActiveIndex: (index: number) => void;
+    readonly setFormTotalErrorCount: ({ errorCount, index, }: {
+        errorCount: number;
+        index: number;
+    }) => void;
+    readonly totalErrorCount?: number;
+};
+type FormsManagerProps = {
+    readonly children: React.ReactNode;
+};
+export declare function FormsManagerProvider({ children }: FormsManagerProps): React.JSX.Element;
+export declare function useFormsManager(): FormsManagerContext;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/elements/BulkUpload/FormsManager/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/elements/BulkUpload/FormsManager/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,mBAAmB,EAAa,MAAM,SAAS,CAAA;AAInE,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAazC,KAAK,mBAAmB,GAAG;IACzB,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAC1C,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACxD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;IAC9B,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,CAAA;IAC3C,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAA;IACtC,QAAQ,CAAC,iBAAiB,EAAE,OAAO,CAAA;IACnC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAA;IAChC,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,QAAQ,CAAC,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAChG,QAAQ,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAChD,QAAQ,CAAC,sBAAsB,EAAE,CAAC,EAChC,UAAU,EACV,KAAK,GACN,EAAE;QACD,UAAU,EAAE,MAAM,CAAA;QAClB,KAAK,EAAE,MAAM,CAAA;KACd,KAAK,IAAI,CAAA;IACV,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAClC,CAAA;AA0BD,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CACnC,CAAA;AACD,wBAAgB,oBAAoB,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,qBAyTnE;AAED,wBAAgB,eAAe,wBAE9B"}

package/dist/elements/BulkUpload/FormsManager/index.js

@@ -0,0 +1,338 @@
+'use client';
+
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useModal } from '@faceless-ui/modal';
+import * as qs from 'qs-esm';
+import React from 'react';
+import { toast } from 'sonner';
+import { fieldReducer } from '../../../forms/Form/fieldReducer.js';
+import { useConfig } from '../../../providers/Config/index.js';
+import { useLocale } from '../../../providers/Locale/index.js';
+import { useTranslation } from '../../../providers/Translation/index.js';
+import { getFormState } from '../../../utilities/getFormState.js';
+import { hasSavePermission as getHasSavePermission } from '../../../utilities/hasSavePermission.js';
+import { useLoadingOverlay } from '../../LoadingOverlay/index.js';
+import { useBulkUpload } from '../index.js';
+import { createFormData } from './createFormData.js';
+import { formsManagementReducer } from './reducer.js';
+const Context = /*#__PURE__*/React.createContext({
+  activeIndex: 0,
+  addFiles: () => Promise.resolve(),
+  collectionSlug: '',
+  docPermissions: undefined,
+  forms: [],
+  getFormDataRef: {
+    current: () => ({})
+  },
+  hasPublishPermission: false,
+  hasSavePermission: false,
+  hasSubmitted: false,
+  isInitializing: false,
+  removeFile: () => {},
+  saveAllDocs: () => Promise.resolve(),
+  setActiveIndex: () => 0,
+  setFormTotalErrorCount: () => {},
+  totalErrorCount: 0
+});
+const initialState = {
+  activeIndex: 0,
+  forms: [],
+  totalErrorCount: 0
+};
+export function FormsManagerProvider({
+  children
+}) {
+  const {
+    config
+  } = useConfig();
+  const {
+    routes: {
+      api
+    },
+    serverURL
+  } = config;
+  const {
+    code
+  } = useLocale();
+  const {
+    i18n,
+    t
+  } = useTranslation();
+  const [hasSubmitted, setHasSubmitted] = React.useState(false);
+  const [docPermissions, setDocPermissions] = React.useState();
+  const [hasSavePermission, setHasSavePermission] = React.useState(false);
+  const [hasPublishPermission, setHasPublishPermission] = React.useState(false);
+  const [hasInitializedState, setHasInitializedState] = React.useState(false);
+  const [hasInitializedDocPermissions, setHasInitializedDocPermissions] = React.useState(false);
+  const [isInitializing, setIsInitializing] = React.useState(false);
+  const [state, dispatch] = React.useReducer(formsManagementReducer, initialState);
+  const {
+    activeIndex,
+    forms,
+    totalErrorCount
+  } = state;
+  const {
+    toggleLoadingOverlay
+  } = useLoadingOverlay();
+  const {
+    closeModal
+  } = useModal();
+  const {
+    collectionSlug,
+    drawerSlug,
+    initialFiles,
+    onSuccess
+  } = useBulkUpload();
+  const hasInitializedWithFiles = React.useRef(false);
+  const initialStateRef = React.useRef(null);
+  const getFormDataRef = React.useRef(() => ({}));
+  const actionURL = `${api}/${collectionSlug}`;
+  const initilizeSharedDocPermissions = React.useCallback(async () => {
+    const params = {
+      locale: code || undefined
+    };
+    const docAccessURL = `/${collectionSlug}/access`;
+    const res = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
+      credentials: 'include',
+      headers: {
+        'Accept-Language': i18n.language,
+        'Content-Type': 'application/json'
+      },
+      method: 'post'
+    });
+    const json = await res.json();
+    const publishedAccessJSON = await fetch(`${serverURL}${api}${docAccessURL}?${qs.stringify(params)}`, {
+      body: JSON.stringify({
+        _status: 'published'
+      }),
+      credentials: 'include',
+      headers: {
+        'Accept-Language': i18n.language,
+        'Content-Type': 'application/json'
+      },
+      method: 'POST'
+    }).then(res_0 => res_0.json());
+    setDocPermissions(json);
+    setHasSavePermission(getHasSavePermission({
+      collectionSlug,
+      docPermissions: json,
+      isEditing: false
+    }));
+    setHasPublishPermission(publishedAccessJSON?.update?.permission);
+    setHasInitializedDocPermissions(true);
+  }, [api, code, collectionSlug, i18n.language, serverURL]);
+  const initializeSharedFormState = React.useCallback(async abortController => {
+    if (abortController?.signal) {
+      abortController.abort('aborting previous fetch for initial form state without files');
+    }
+    try {
+      const {
+        state: formStateWithoutFiles
+      } = await getFormState({
+        apiRoute: config.routes.api,
+        body: {
+          collectionSlug,
+          locale: code,
+          operation: 'create',
+          schemaPath: collectionSlug
+        },
+        // onError: onLoadError,
+        serverURL: config.serverURL,
+        signal: abortController?.signal
+      });
+      initialStateRef.current = formStateWithoutFiles;
+      setHasInitializedState(true);
+    } catch (error) {
+      // swallow error
+    }
+  }, [code, collectionSlug, config.routes.api, config.serverURL]);
+  const setActiveIndex = React.useCallback(index => {
+    const currentFormsData = getFormDataRef.current();
+    dispatch({
+      type: 'REPLACE',
+      state: {
+        activeIndex: index,
+        forms: forms.map((form, i) => {
+          if (i === activeIndex) {
+            return {
+              errorCount: form.errorCount,
+              formState: currentFormsData
+            };
+          }
+          return form;
+        })
+      }
+    });
+  }, [forms, activeIndex]);
+  const addFiles = React.useCallback(async files => {
+    toggleLoadingOverlay({
+      isLoading: true,
+      key: 'addingDocs'
+    });
+    if (!hasInitializedState) {
+      await initializeSharedFormState();
+    }
+    dispatch({
+      type: 'ADD_FORMS',
+      files,
+      initialState: initialStateRef.current
+    });
+    toggleLoadingOverlay({
+      isLoading: false,
+      key: 'addingDocs'
+    });
+  }, [initializeSharedFormState, hasInitializedState, toggleLoadingOverlay]);
+  const removeFile = React.useCallback(index_0 => {
+    dispatch({
+      type: 'REMOVE_FORM',
+      index: index_0
+    });
+  }, []);
+  const setFormTotalErrorCount = React.useCallback(({
+    errorCount,
+    index: index_1
+  }) => {
+    dispatch({
+      type: 'UPDATE_ERROR_COUNT',
+      count: errorCount,
+      index: index_1
+    });
+  }, []);
+  const saveAllDocs = React.useCallback(async ({
+    overrides
+  } = {}) => {
+    const currentFormsData_0 = getFormDataRef.current();
+    const currentForms = [...forms];
+    currentForms[activeIndex] = {
+      errorCount: currentForms[activeIndex].errorCount,
+      formState: currentFormsData_0
+    };
+    const newDocs = [];
+    const promises = currentForms.map(async (form_0, i_0) => {
+      try {
+        toggleLoadingOverlay({
+          isLoading: true,
+          key: 'saveAllDocs',
+          loadingText: t('general:uploading')
+        });
+        const req = await fetch(actionURL, {
+          body: createFormData(form_0.formState, overrides),
+          method: 'POST'
+        });
+        const json_0 = await req.json();
+        if (req.status === 201 && json_0?.doc) {
+          newDocs.push(json_0.doc);
+        }
+        // should expose some sort of helper for this
+        if (json_0?.errors?.length) {
+          const [fieldErrors, nonFieldErrors] = json_0.errors.reduce(([fieldErrs, nonFieldErrs], err) => {
+            const newFieldErrs = [];
+            const newNonFieldErrs = [];
+            if (err?.message) {
+              newNonFieldErrs.push(err);
+            }
+            if (Array.isArray(err?.data?.errors)) {
+              err.data?.errors.forEach(dataError => {
+                if (dataError?.field) {
+                  newFieldErrs.push(dataError);
+                } else {
+                  newNonFieldErrs.push(dataError);
+                }
+              });
+            }
+            return [[...fieldErrs, ...newFieldErrs], [...nonFieldErrs, ...newNonFieldErrs]];
+          }, [[], []]);
+          currentForms[i_0] = {
+            errorCount: fieldErrors.length,
+            formState: fieldReducer(currentForms[i_0].formState, {
+              type: 'ADD_SERVER_ERRORS',
+              errors: fieldErrors
+            })
+          };
+        }
+      } catch (error_0) {
+        // swallow error
+      } finally {
+        setHasSubmitted(true);
+        toggleLoadingOverlay({
+          isLoading: false,
+          key: 'saveAllDocs'
+        });
+      }
+    });
+    await Promise.all(promises);
+    const remainingForms = currentForms.filter(({
+      errorCount: errorCount_0
+    }) => errorCount_0 > 0);
+    const successCount = Math.max(0, currentForms.length - remainingForms.length);
+    const errorCount_1 = currentForms.length - successCount;
+    if (successCount) {
+      toast.success(`Successfully saved ${successCount} files`);
+      if (typeof onSuccess === 'function') {
+        onSuccess(newDocs, errorCount_1);
+      }
+    }
+    if (errorCount_1) {
+      toast.error(`Failed to save ${errorCount_1} files`);
+    } else {
+      closeModal(drawerSlug);
+    }
+    dispatch({
+      type: 'REPLACE',
+      state: {
+        activeIndex: 0,
+        forms: remainingForms,
+        totalErrorCount: remainingForms.reduce((acc, {
+          errorCount: errorCount_2
+        }) => acc + errorCount_2, 0)
+      }
+    });
+  }, [actionURL, activeIndex, forms, onSuccess, t, toggleLoadingOverlay, closeModal, drawerSlug]);
+  React.useEffect(() => {
+    if (!collectionSlug) {
+      return;
+    }
+    if (!hasInitializedState) {
+      void initializeSharedFormState();
+    }
+    if (!hasInitializedDocPermissions) {
+      void initilizeSharedDocPermissions();
+    }
+    if (initialFiles) {
+      if (!hasInitializedState || !hasInitializedDocPermissions) {
+        setIsInitializing(true);
+      } else {
+        setIsInitializing(false);
+      }
+    }
+    if (hasInitializedState && initialFiles && !hasInitializedWithFiles.current) {
+      void addFiles(initialFiles);
+      hasInitializedWithFiles.current = true;
+    }
+    return;
+  }, [addFiles, initialFiles, initializeSharedFormState, initilizeSharedDocPermissions, collectionSlug, hasInitializedState, hasInitializedDocPermissions]);
+  return /*#__PURE__*/_jsx(Context.Provider, {
+    value: {
+      activeIndex: state.activeIndex,
+      addFiles,
+      collectionSlug,
+      docPermissions,
+      forms,
+      getFormDataRef,
+      hasPublishPermission,
+      hasSavePermission,
+      hasSubmitted,
+      isInitializing,
+      removeFile,
+      saveAllDocs,
+      setActiveIndex,
+      setFormTotalErrorCount,
+      totalErrorCount
+    },
+    children: children
+  });
+}
+export function useFormsManager() {
+  return React.useContext(Context);
+}
+//# sourceMappingURL=index.js.map