@frameless/strapi-plugin-flo-legal-embed 2.0.0

package/dist/_chunks/index-BsjCjaop.mjs

@@ -0,0 +1,421 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { Field, TextInput, Combobox, ComboboxOption } from "@strapi/design-system";
+import { useIntl } from "react-intl";
+import { useNotification, useFetchClient } from "@strapi/strapi/admin";
+import * as React from "react";
+import React__default, { useEffect } from "react";
+import { P as PLUGIN_ID, R as RESOLVE_CONFIG, g as getTranslation } from "./index-DuaW1Ojp.mjs";
+var withSelector = { exports: {} };
+var useSyncExternalStoreWithSelector_production = {};
+/**
+ * @license React
+ * use-sync-external-store-with-selector.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreWithSelector_production;
+function requireUseSyncExternalStoreWithSelector_production() {
+  if (hasRequiredUseSyncExternalStoreWithSelector_production) return useSyncExternalStoreWithSelector_production;
+  hasRequiredUseSyncExternalStoreWithSelector_production = 1;
+  var React2 = React__default;
+  function is(x, y) {
+    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+  }
+  var objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = React2.useSyncExternalStore, useRef = React2.useRef, useEffect2 = React2.useEffect, useMemo = React2.useMemo, useDebugValue = React2.useDebugValue;
+  useSyncExternalStoreWithSelector_production.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+    var instRef = useRef(null);
+    if (null === instRef.current) {
+      var inst = { hasValue: false, value: null };
+      instRef.current = inst;
+    } else inst = instRef.current;
+    instRef = useMemo(
+      function() {
+        function memoizedSelector(nextSnapshot) {
+          if (!hasMemo) {
+            hasMemo = true;
+            memoizedSnapshot = nextSnapshot;
+            nextSnapshot = selector(nextSnapshot);
+            if (void 0 !== isEqual && inst.hasValue) {
+              var currentSelection = inst.value;
+              if (isEqual(currentSelection, nextSnapshot))
+                return memoizedSelection = currentSelection;
+            }
+            return memoizedSelection = nextSnapshot;
+          }
+          currentSelection = memoizedSelection;
+          if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+          var nextSelection = selector(nextSnapshot);
+          if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+            return memoizedSnapshot = nextSnapshot, currentSelection;
+          memoizedSnapshot = nextSnapshot;
+          return memoizedSelection = nextSelection;
+        }
+        var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+        return [
+          function() {
+            return memoizedSelector(getSnapshot());
+          },
+          null === maybeGetServerSnapshot ? void 0 : function() {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }
+        ];
+      },
+      [getSnapshot, getServerSnapshot, selector, isEqual]
+    );
+    var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+    useEffect2(
+      function() {
+        inst.hasValue = true;
+        inst.value = value;
+      },
+      [value]
+    );
+    useDebugValue(value);
+    return value;
+  };
+  return useSyncExternalStoreWithSelector_production;
+}
+var useSyncExternalStoreWithSelector_development = {};
+/**
+ * @license React
+ * use-sync-external-store-with-selector.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredUseSyncExternalStoreWithSelector_development;
+function requireUseSyncExternalStoreWithSelector_development() {
+  if (hasRequiredUseSyncExternalStoreWithSelector_development) return useSyncExternalStoreWithSelector_development;
+  hasRequiredUseSyncExternalStoreWithSelector_development = 1;
+  "production" !== process.env.NODE_ENV && function() {
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var React2 = React__default, objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = React2.useSyncExternalStore, useRef = React2.useRef, useEffect2 = React2.useEffect, useMemo = React2.useMemo, useDebugValue = React2.useDebugValue;
+    useSyncExternalStoreWithSelector_development.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+      var instRef = useRef(null);
+      if (null === instRef.current) {
+        var inst = { hasValue: false, value: null };
+        instRef.current = inst;
+      } else inst = instRef.current;
+      instRef = useMemo(
+        function() {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = true;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot))
+                  return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot))
+              return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
+              return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [
+            function() {
+              return memoizedSelector(getSnapshot());
+            },
+            null === maybeGetServerSnapshot ? void 0 : function() {
+              return memoizedSelector(maybeGetServerSnapshot());
+            }
+          ];
+        },
+        [getSnapshot, getServerSnapshot, selector, isEqual]
+      );
+      var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+      useEffect2(
+        function() {
+          inst.hasValue = true;
+          inst.value = value;
+        },
+        [value]
+      );
+      useDebugValue(value);
+      return value;
+    };
+    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  }();
+  return useSyncExternalStoreWithSelector_development;
+}
+if (process.env.NODE_ENV === "production") {
+  withSelector.exports = requireUseSyncExternalStoreWithSelector_production();
+} else {
+  withSelector.exports = requireUseSyncExternalStoreWithSelector_development();
+}
+var withSelectorExports = withSelector.exports;
+var ContextKey = /* @__PURE__ */ Symbol.for(`react-redux-context`);
+var gT = typeof globalThis !== "undefined" ? globalThis : (
+  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+  {}
+);
+function getContext() {
+  if (!React.createContext) return {};
+  const contextMap = gT[ContextKey] ??= /* @__PURE__ */ new Map();
+  let realContext = contextMap.get(React.createContext);
+  if (!realContext) {
+    realContext = React.createContext(
+      null
+    );
+    if (process.env.NODE_ENV !== "production") {
+      realContext.displayName = "ReactRedux";
+    }
+    contextMap.set(React.createContext, realContext);
+  }
+  return realContext;
+}
+var ReactReduxContext = /* @__PURE__ */ getContext();
+function createReduxContextHook(context = ReactReduxContext) {
+  return function useReduxContext2() {
+    const contextValue = React.useContext(context);
+    if (process.env.NODE_ENV !== "production" && !contextValue) {
+      throw new Error(
+        "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+      );
+    }
+    return contextValue;
+  };
+}
+var useReduxContext = /* @__PURE__ */ createReduxContextHook();
+function createStoreHook(context = ReactReduxContext) {
+  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
+    // @ts-ignore
+    createReduxContextHook(context)
+  );
+  const useStore2 = () => {
+    const { store } = useReduxContext2();
+    return store;
+  };
+  Object.assign(useStore2, {
+    withTypes: () => useStore2
+  });
+  return useStore2;
+}
+var useStore = /* @__PURE__ */ createStoreHook();
+function createDispatchHook(context = ReactReduxContext) {
+  const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
+  const useDispatch2 = () => {
+    const store = useStore2();
+    return store.dispatch;
+  };
+  Object.assign(useDispatch2, {
+    withTypes: () => useDispatch2
+  });
+  return useDispatch2;
+}
+var useDispatch = /* @__PURE__ */ createDispatchHook();
+var refEquality = (a, b) => a === b;
+function createSelectorHook(context = ReactReduxContext) {
+  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
+  const useSelector2 = (selector, equalityFnOrOptions = {}) => {
+    const { equalityFn = refEquality } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
+    if (process.env.NODE_ENV !== "production") {
+      if (!selector) {
+        throw new Error(`You must pass a selector to useSelector`);
+      }
+      if (typeof selector !== "function") {
+        throw new Error(`You must pass a function as a selector to useSelector`);
+      }
+      if (typeof equalityFn !== "function") {
+        throw new Error(
+          `You must pass a function as an equality function to useSelector`
+        );
+      }
+    }
+    const reduxContext = useReduxContext2();
+    const { store, subscription, getServerState } = reduxContext;
+    const firstRun = React.useRef(true);
+    const wrappedSelector = React.useCallback(
+      {
+        [selector.name](state) {
+          const selected = selector(state);
+          if (process.env.NODE_ENV !== "production") {
+            const { devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? {} : equalityFnOrOptions;
+            const { identityFunctionCheck, stabilityCheck } = reduxContext;
+            const {
+              identityFunctionCheck: finalIdentityFunctionCheck,
+              stabilityCheck: finalStabilityCheck
+            } = {
+              stabilityCheck,
+              identityFunctionCheck,
+              ...devModeChecks
+            };
+            if (finalStabilityCheck === "always" || finalStabilityCheck === "once" && firstRun.current) {
+              const toCompare = selector(state);
+              if (!equalityFn(selected, toCompare)) {
+                let stack = void 0;
+                try {
+                  throw new Error();
+                } catch (e) {
+                  ({ stack } = e);
+                }
+                console.warn(
+                  "Selector " + (selector.name || "unknown") + " returned a different result when called with the same parameters. This can lead to unnecessary rerenders.\nSelectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization",
+                  {
+                    state,
+                    selected,
+                    selected2: toCompare,
+                    stack
+                  }
+                );
+              }
+            }
+            if (finalIdentityFunctionCheck === "always" || finalIdentityFunctionCheck === "once" && firstRun.current) {
+              if (selected === state) {
+                let stack = void 0;
+                try {
+                  throw new Error();
+                } catch (e) {
+                  ({ stack } = e);
+                }
+                console.warn(
+                  "Selector " + (selector.name || "unknown") + " returned the root state when called. This can lead to unnecessary rerenders.\nSelectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.",
+                  { stack }
+                );
+              }
+            }
+            if (firstRun.current) firstRun.current = false;
+          }
+          return selected;
+        }
+      }[selector.name],
+      [selector]
+    );
+    const selectedState = withSelectorExports.useSyncExternalStoreWithSelector(
+      subscription.addNestedSub,
+      store.getState,
+      getServerState || store.getState,
+      wrappedSelector,
+      equalityFn
+    );
+    React.useDebugValue(selectedState);
+    return selectedState;
+  };
+  Object.assign(useSelector2, {
+    withTypes: () => useSelector2
+  });
+  return useSelector2;
+}
+var useSelector = /* @__PURE__ */ createSelectorHook();
+const usePluginConfig = () => {
+  const dispatch = useDispatch();
+  const { toggleNotification } = useNotification();
+  const { formatMessage } = useIntl();
+  const { isLoading, config, checks } = useSelector(
+    (state) => state[`${PLUGIN_ID}_config`]
+  );
+  const client = useFetchClient();
+  useEffect(() => {
+    if (!isLoading && config !== null) {
+      return;
+    }
+    const abortController = new AbortController();
+    const fetchData = async () => {
+      try {
+        const endpoint = `/${PLUGIN_ID}/config`;
+        const { data } = await client.get(endpoint, {
+          signal: abortController.signal
+        });
+        return data ?? null;
+      } catch (err) {
+        console.error(err);
+        if (!abortController.signal.aborted) {
+          toggleNotification({
+            type: "warning",
+            message: formatMessage({
+              id: getTranslation("notification.error"),
+              defaultMessage: "An error occurred while fetching data"
+            })
+          });
+        }
+        return null;
+      }
+    };
+    fetchData().then((data) => dispatch({ type: RESOLVE_CONFIG, data }));
+    return () => abortController.abort();
+  }, [client, config, dispatch, isLoading, toggleNotification, formatMessage]);
+  return { config, checks, isLoading };
+};
+const FloLegalCombobox = ({
+  value,
+  onChange,
+  name,
+  required,
+  type,
+  placeholder,
+  disabled,
+  error,
+  label,
+  hint
+}) => {
+  const { config, checks, isLoading } = usePluginConfig();
+  const { formatMessage } = useIntl();
+  const generateFloLegalData = (params) => new URLSearchParams({ ...params }).toString();
+  if (!config?.api_url || !config?.token) {
+    return /* @__PURE__ */ jsxs(
+      Field.Root,
+      {
+        name,
+        error,
+        hint: formatMessage({
+          id: getTranslation("flo-legal-embed.disabled.hint"),
+          defaultMessage: "Ensure FLO_LEGAL_API_URL and FLO_LEGAL_API_TOKEN are configured to enable this field."
+        }),
+        children: [
+          /* @__PURE__ */ jsx(Field.Label, { children: label }),
+          /* @__PURE__ */ jsx(
+            TextInput,
+            {
+              name,
+              value: "",
+              placeholder: formatMessage({
+                id: getTranslation("flo-legal-embed.disabled.placeholder"),
+                defaultMessage: "This field is disabled until necessary settings are configured."
+              }),
+              disabled: true
+            }
+          ),
+          /* @__PURE__ */ jsx(Field.Hint, {}),
+          /* @__PURE__ */ jsx(Field.Error, {})
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Field.Root, { name, error, hint, required, children: [
+    /* @__PURE__ */ jsx(Field.Label, { children: label }),
+    /* @__PURE__ */ jsx(
+      Combobox,
+      {
+        placeholder,
+        "aria-label": label,
+        disabled,
+        required,
+        value: value ?? "",
+        loading: isLoading,
+        onChange: (val) => onChange({ target: { name, value: val, type } }),
+        children: checks.map(({ identifier, name: name2 }) => /* @__PURE__ */ jsx(ComboboxOption, { value: generateFloLegalData({ identifier }), children: name2 }, identifier))
+      }
+    ),
+    /* @__PURE__ */ jsx(Field.Hint, {}),
+    /* @__PURE__ */ jsx(Field.Error, {})
+  ] });
+};
+export {
+  FloLegalCombobox
+};

package/dist/_chunks/index-Doljqns2.js

@@ -0,0 +1,141 @@
+"use strict";
+const jsxRuntime = require("react/jsx-runtime");
+const designSystem = require("@strapi/design-system");
+const icons = require("@strapi/icons");
+const immer = require("immer");
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const FloLegalIcon = () => /* @__PURE__ */ jsxRuntime.jsx(
+  designSystem.Flex,
+  {
+    justifyContent: "center",
+    alignItems: "center",
+    width: 7,
+    height: 6,
+    background: "primary100",
+    borderColor: "primary200",
+    borderWidth: "1px",
+    borderStyle: "solid",
+    hasRadius: true,
+    "aria-hidden": true,
+    children: /* @__PURE__ */ jsxRuntime.jsx(icons.ManyWays, { color: "primary600" })
+  }
+);
+const PLUGIN_ID = "flo-legal-embed";
+const RESOLVE_CONFIG = `${PLUGIN_ID}/resolve-config`;
+const initialState = {
+  isLoading: true,
+  config: null,
+  checks: []
+};
+const configReducer = immer.produce(
+  // eslint-disable-next-line consistent-return
+  (state = initialState, action) => {
+    switch (action.type) {
+      case RESOLVE_CONFIG: {
+        const { data } = action;
+        state.isLoading = false;
+        state.config = data?.config ?? null;
+        state.checks = data?.checks ?? [];
+        break;
+      }
+      default:
+        return state;
+    }
+  }
+);
+const reducers = {
+  [`${PLUGIN_ID}_config`]: configReducer
+};
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const prefixPluginTranslations = (translate, pluginId) => {
+  return Object.keys(translate).reduce((acc, current) => {
+    acc[`${pluginId}.${current}`] = translate[current];
+    return acc;
+  }, {});
+};
+const index = {
+  register(app) {
+    app.addReducers(reducers);
+    app.customFields.register({
+      name: PLUGIN_ID,
+      pluginId: PLUGIN_ID,
+      type: "string",
+      icon: FloLegalIcon,
+      intlLabel: {
+        id: getTranslation("flo-legal-embed.label"),
+        defaultMessage: "Choose an Embedded Flo Legal Form"
+      },
+      intlDescription: {
+        id: getTranslation("flo-legal-embed.description"),
+        defaultMessage: "Saves the unique identifier of the selected decision tree in the database."
+      },
+      components: {
+        Input: async () => {
+          const { FloLegalCombobox } = await Promise.resolve().then(() => require("./index-IrSgMm3Q.js"));
+          return { default: FloLegalCombobox };
+        }
+      },
+      options: {
+        advanced: [
+          {
+            sectionTitle: {
+              id: "global.settings",
+              defaultMessage: "Settings"
+            },
+            items: [
+              {
+                name: "required",
+                type: "checkbox",
+                intlLabel: {
+                  id: "form.attribute.item.requiredField",
+                  defaultMessage: "Required field"
+                },
+                description: {
+                  id: "form.attribute.item.requiredField.description",
+                  defaultMessage: "You won't be able to create an entry if this field is empty"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    });
+  },
+  async registerTrads({ locales }) {
+    const importedTranslations = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("./en-DA9_CZNh.js")), "./translations/nl.json": () => Promise.resolve().then(() => require("./nl-WRqysNLk.js")) }), `./translations/${locale}.json`, 3).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, PLUGIN_ID),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return Promise.resolve(importedTranslations);
+  }
+};
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.RESOLVE_CONFIG = RESOLVE_CONFIG;
+exports.getTranslation = getTranslation;
+exports.index = index;

package/dist/_chunks/index-DuaW1Ojp.mjs

@@ -0,0 +1,142 @@
+import { jsx } from "react/jsx-runtime";
+import { Flex } from "@strapi/design-system";
+import { ManyWays } from "@strapi/icons";
+import { produce } from "immer";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const FloLegalIcon = () => /* @__PURE__ */ jsx(
+  Flex,
+  {
+    justifyContent: "center",
+    alignItems: "center",
+    width: 7,
+    height: 6,
+    background: "primary100",
+    borderColor: "primary200",
+    borderWidth: "1px",
+    borderStyle: "solid",
+    hasRadius: true,
+    "aria-hidden": true,
+    children: /* @__PURE__ */ jsx(ManyWays, { color: "primary600" })
+  }
+);
+const PLUGIN_ID = "flo-legal-embed";
+const RESOLVE_CONFIG = `${PLUGIN_ID}/resolve-config`;
+const initialState = {
+  isLoading: true,
+  config: null,
+  checks: []
+};
+const configReducer = produce(
+  // eslint-disable-next-line consistent-return
+  (state = initialState, action) => {
+    switch (action.type) {
+      case RESOLVE_CONFIG: {
+        const { data } = action;
+        state.isLoading = false;
+        state.config = data?.config ?? null;
+        state.checks = data?.checks ?? [];
+        break;
+      }
+      default:
+        return state;
+    }
+  }
+);
+const reducers = {
+  [`${PLUGIN_ID}_config`]: configReducer
+};
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const prefixPluginTranslations = (translate, pluginId) => {
+  return Object.keys(translate).reduce((acc, current) => {
+    acc[`${pluginId}.${current}`] = translate[current];
+    return acc;
+  }, {});
+};
+const index = {
+  register(app) {
+    app.addReducers(reducers);
+    app.customFields.register({
+      name: PLUGIN_ID,
+      pluginId: PLUGIN_ID,
+      type: "string",
+      icon: FloLegalIcon,
+      intlLabel: {
+        id: getTranslation("flo-legal-embed.label"),
+        defaultMessage: "Choose an Embedded Flo Legal Form"
+      },
+      intlDescription: {
+        id: getTranslation("flo-legal-embed.description"),
+        defaultMessage: "Saves the unique identifier of the selected decision tree in the database."
+      },
+      components: {
+        Input: async () => {
+          const { FloLegalCombobox } = await import("./index-BsjCjaop.mjs");
+          return { default: FloLegalCombobox };
+        }
+      },
+      options: {
+        advanced: [
+          {
+            sectionTitle: {
+              id: "global.settings",
+              defaultMessage: "Settings"
+            },
+            items: [
+              {
+                name: "required",
+                type: "checkbox",
+                intlLabel: {
+                  id: "form.attribute.item.requiredField",
+                  defaultMessage: "Required field"
+                },
+                description: {
+                  id: "form.attribute.item.requiredField.description",
+                  defaultMessage: "You won't be able to create an entry if this field is empty"
+                }
+              }
+            ]
+          }
+        ]
+      }
+    });
+  },
+  async registerTrads({ locales }) {
+    const importedTranslations = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => import("./en-DL8lkwfI.mjs"), "./translations/nl.json": () => import("./nl--quOP7M_.mjs") }), `./translations/${locale}.json`, 3).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, PLUGIN_ID),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return Promise.resolve(importedTranslations);
+  }
+};
+export {
+  PLUGIN_ID as P,
+  RESOLVE_CONFIG as R,
+  getTranslation as g,
+  index as i
+};