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

package/dist/_chunks/index-IrSgMm3Q.js

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const jsxRuntime = require("react/jsx-runtime");
+const designSystem = require("@strapi/design-system");
+const reactIntl = require("react-intl");
+const admin = require("@strapi/strapi/admin");
+const React = require("react");
+const index = require("./index-Doljqns2.js");
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespace(React);
+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__namespace.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, useEffect = 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]);
+    useEffect(
+      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__namespace.default, objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore = React2.useSyncExternalStore, useRef = React2.useRef, useEffect = 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]);
+      useEffect(
+        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__namespace.createContext) return {};
+  const contextMap = gT[ContextKey] ??= /* @__PURE__ */ new Map();
+  let realContext = contextMap.get(React__namespace.createContext);
+  if (!realContext) {
+    realContext = React__namespace.createContext(
+      null
+    );
+    if (process.env.NODE_ENV !== "production") {
+      realContext.displayName = "ReactRedux";
+    }
+    contextMap.set(React__namespace.createContext, realContext);
+  }
+  return realContext;
+}
+var ReactReduxContext = /* @__PURE__ */ getContext();
+function createReduxContextHook(context = ReactReduxContext) {
+  return function useReduxContext2() {
+    const contextValue = React__namespace.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__namespace.useRef(true);
+    const wrappedSelector = React__namespace.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__namespace.useDebugValue(selectedState);
+    return selectedState;
+  };
+  Object.assign(useSelector2, {
+    withTypes: () => useSelector2
+  });
+  return useSelector2;
+}
+var useSelector = /* @__PURE__ */ createSelectorHook();
+const usePluginConfig = () => {
+  const dispatch = useDispatch();
+  const { toggleNotification } = admin.useNotification();
+  const { formatMessage } = reactIntl.useIntl();
+  const { isLoading, config, checks } = useSelector(
+    (state) => state[`${index.PLUGIN_ID}_config`]
+  );
+  const client = admin.useFetchClient();
+  React.useEffect(() => {
+    if (!isLoading && config !== null) {
+      return;
+    }
+    const abortController = new AbortController();
+    const fetchData = async () => {
+      try {
+        const endpoint = `/${index.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: index.getTranslation("notification.error"),
+              defaultMessage: "An error occurred while fetching data"
+            })
+          });
+        }
+        return null;
+      }
+    };
+    fetchData().then((data) => dispatch({ type: index.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 } = reactIntl.useIntl();
+  const generateFloLegalData = (params) => new URLSearchParams({ ...params }).toString();
+  if (!config?.api_url || !config?.token) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      designSystem.Field.Root,
+      {
+        name,
+        error,
+        hint: formatMessage({
+          id: index.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__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: label }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.TextInput,
+            {
+              name,
+              value: "",
+              placeholder: formatMessage({
+                id: index.getTranslation("flo-legal-embed.disabled.placeholder"),
+                defaultMessage: "This field is disabled until necessary settings are configured."
+              }),
+              disabled: true
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {}),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Error, {})
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { name, error, hint, required, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.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__ */ jsxRuntime.jsx(designSystem.ComboboxOption, { value: generateFloLegalData({ identifier }), children: name2 }, identifier))
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Hint, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Error, {})
+  ] });
+};
+exports.FloLegalCombobox = FloLegalCombobox;

package/dist/_chunks/nl--quOP7M_.mjs

@@ -0,0 +1,9 @@
+const nl = {
+  "flo-legal-embed.label": "Kies een ingebed Flo Legal formulier",
+  "flo-legal-embed.description": "Slaat de unieke identificatie van het geselecteerde formulier op in de database.",
+  "flo-legal-embed.disabled.placeholder": "Dit veld is uitgeschakeld totdat de vereiste instellingen zijn geconfigureerd.",
+  "flo-legal-embed.disabled.hint": "Zorg ervoor dat FLO_LEGAL_API_URL en FLO_LEGAL_API_TOKEN correct zijn geconfigureerd om dit veld in te schakelen."
+};
+export {
+  nl as default
+};

package/dist/_chunks/nl-WRqysNLk.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nl = {
+  "flo-legal-embed.label": "Kies een ingebed Flo Legal formulier",
+  "flo-legal-embed.description": "Slaat de unieke identificatie van het geselecteerde formulier op in de database.",
+  "flo-legal-embed.disabled.placeholder": "Dit veld is uitgeschakeld totdat de vereiste instellingen zijn geconfigureerd.",
+  "flo-legal-embed.disabled.hint": "Zorg ervoor dat FLO_LEGAL_API_URL en FLO_LEGAL_API_TOKEN correct zijn geconfigureerd om dit veld in te schakelen."
+};
+exports.default = nl;

package/dist/admin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const index = require("../_chunks/index-Doljqns2.js");
+module.exports = index.index;

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-DuaW1Ojp.mjs";
+export {
+  i as default
+};

package/dist/server/index.js

@@ -0,0 +1,86 @@
+"use strict";
+const config = {
+  default: {}
+  // export default {
+  //   default: {},
+  //   validator: (config: Config) => {
+  //     if (!config) {
+  //       return;
+  //     }
+  //     if (!config?.api_url) {
+  //       console.warn('strapi-plugin-flo-legal-embed: Warning: Missing api_url prop.');
+  //     }
+  //     if (!config?.token) {
+  //       console.warn('strapi-plugin-flo-legal-embed: Warning: Missing token prop.');
+  //     }
+  //   },
+  // };
+};
+const PLUGIN_ID = "flo-legal-embed";
+const floLegalEmbed = ({ strapi }) => ({
+  async config(ctx) {
+    try {
+      const config2 = await strapi.plugin(PLUGIN_ID).service("plugin").getConfig();
+      if (!config2?.api_url || !config2?.token) {
+        ctx.body = { config: config2 };
+        return;
+      }
+      const response = await fetch(`${config2.api_url}/block-publications?type=CHECK`, {
+        headers: {
+          "x-api-key": config2.token
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`API request failed with status ${response.status}`);
+      }
+      const checks = await response.json();
+      ctx.body = { config: config2, checks };
+    } catch (error) {
+      console.error(error);
+      ctx.badRequest(`Failed to load ${PLUGIN_ID} config: ${error.message}`);
+    }
+  }
+});
+const controllers = {
+  "flo-legal-embed": floLegalEmbed
+};
+const register = ({ strapi }) => {
+  strapi.customFields.register({
+    name: PLUGIN_ID,
+    plugin: PLUGIN_ID,
+    type: "string"
+  });
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/config",
+      handler: `${PLUGIN_ID}.config`,
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+};
+const routes = {
+  "admin-api": admin
+};
+const plugin = ({ strapi }) => ({
+  getConfig() {
+    const data = strapi.config.get(`plugin::${PLUGIN_ID}`);
+    return data;
+  }
+});
+const services = {
+  plugin
+};
+const index = {
+  config,
+  controllers,
+  routes,
+  services,
+  register
+};
+module.exports = index;

package/dist/server/index.mjs

@@ -0,0 +1,87 @@
+const config = {
+  default: {}
+  // export default {
+  //   default: {},
+  //   validator: (config: Config) => {
+  //     if (!config) {
+  //       return;
+  //     }
+  //     if (!config?.api_url) {
+  //       console.warn('strapi-plugin-flo-legal-embed: Warning: Missing api_url prop.');
+  //     }
+  //     if (!config?.token) {
+  //       console.warn('strapi-plugin-flo-legal-embed: Warning: Missing token prop.');
+  //     }
+  //   },
+  // };
+};
+const PLUGIN_ID = "flo-legal-embed";
+const floLegalEmbed = ({ strapi }) => ({
+  async config(ctx) {
+    try {
+      const config2 = await strapi.plugin(PLUGIN_ID).service("plugin").getConfig();
+      if (!config2?.api_url || !config2?.token) {
+        ctx.body = { config: config2 };
+        return;
+      }
+      const response = await fetch(`${config2.api_url}/block-publications?type=CHECK`, {
+        headers: {
+          "x-api-key": config2.token
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`API request failed with status ${response.status}`);
+      }
+      const checks = await response.json();
+      ctx.body = { config: config2, checks };
+    } catch (error) {
+      console.error(error);
+      ctx.badRequest(`Failed to load ${PLUGIN_ID} config: ${error.message}`);
+    }
+  }
+});
+const controllers = {
+  "flo-legal-embed": floLegalEmbed
+};
+const register = ({ strapi }) => {
+  strapi.customFields.register({
+    name: PLUGIN_ID,
+    plugin: PLUGIN_ID,
+    type: "string"
+  });
+};
+const admin = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/config",
+      handler: `${PLUGIN_ID}.config`,
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+};
+const routes = {
+  "admin-api": admin
+};
+const plugin = ({ strapi }) => ({
+  getConfig() {
+    const data = strapi.config.get(`plugin::${PLUGIN_ID}`);
+    return data;
+  }
+});
+const services = {
+  plugin
+};
+const index = {
+  config,
+  controllers,
+  routes,
+  services,
+  register
+};
+export {
+  index as default
+};