@localazy/strapi-plugin 1.0.4 → 1.0.9

package/dist/_chunks/index-BIbKC7-V.mjs

@@ -0,0 +1,432 @@
+import { createElement, isValidElement, cloneElement, Children, Fragment, useContext } from "react";
+import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-DWwsNxpa.mjs";
+import { w as warnOnce, i as isString, a as warn, b as isObject, I as I18nContext } from "./useTranslation-CZQ4lU1m.mjs";
+import { u } from "./useTranslation-CZQ4lU1m.mjs";
+import { g as getI18n, a as getDefaults } from "./initReactI18next-MHHxeg_9.mjs";
+import { i, s, b } from "./initReactI18next-MHHxeg_9.mjs";
+var voidElements = {
+  "area": true,
+  "base": true,
+  "br": true,
+  "col": true,
+  "embed": true,
+  "hr": true,
+  "img": true,
+  "input": true,
+  "link": true,
+  "meta": true,
+  "param": true,
+  "source": true,
+  "track": true,
+  "wbr": true
+};
+const e = /* @__PURE__ */ getDefaultExportFromCjs(voidElements);
+var t = /\s([^'"/\s><]+?)[\s/>]|([^\s=]+)=\s?(".*?"|'.*?')/g;
+function n(n2) {
+  var r2 = { type: "tag", name: "", voidElement: false, attrs: {}, children: [] }, i3 = n2.match(/<\/?([^\s]+?)[/\s>]/);
+  if (i3 && (r2.name = i3[1], (e[i3[1]] || "/" === n2.charAt(n2.length - 2)) && (r2.voidElement = true), r2.name.startsWith("!--"))) {
+    var s3 = n2.indexOf("-->");
+    return { type: "comment", comment: -1 !== s3 ? n2.slice(4, s3) : "" };
+  }
+  for (var a2 = new RegExp(t), c2 = null; null !== (c2 = a2.exec(n2)); ) if (c2[0].trim()) if (c2[1]) {
+    var o = c2[1].trim(), l = [o, ""];
+    o.indexOf("=") > -1 && (l = o.split("=")), r2.attrs[l[0]] = l[1], a2.lastIndex--;
+  } else c2[2] && (r2.attrs[c2[2]] = c2[3].trim().substring(1, c2[3].length - 1));
+  return r2;
+}
+var r = /<[a-zA-Z0-9\-\!\/](?:"[^"]*"|'[^']*'|[^'">])*>/g, i2 = /^\s*$/, s2 = /* @__PURE__ */ Object.create(null);
+function a(e2, t2) {
+  switch (t2.type) {
+    case "text":
+      return e2 + t2.content;
+    case "tag":
+      return e2 += "<" + t2.name + (t2.attrs ? function(e3) {
+        var t3 = [];
+        for (var n2 in e3) t3.push(n2 + '="' + e3[n2] + '"');
+        return t3.length ? " " + t3.join(" ") : "";
+      }(t2.attrs) : "") + (t2.voidElement ? "/>" : ">"), t2.voidElement ? e2 : e2 + t2.children.reduce(a, "") + "</" + t2.name + ">";
+    case "comment":
+      return e2 + "<!--" + t2.comment + "-->";
+  }
+}
+var c = { parse: function(e2, t2) {
+  t2 || (t2 = {}), t2.components || (t2.components = s2);
+  var a2, c2 = [], o = [], l = -1, m = false;
+  if (0 !== e2.indexOf("<")) {
+    var u2 = e2.indexOf("<");
+    c2.push({ type: "text", content: -1 === u2 ? e2 : e2.substring(0, u2) });
+  }
+  return e2.replace(r, function(r2, s3) {
+    if (m) {
+      if (r2 !== "</" + a2.name + ">") return;
+      m = false;
+    }
+    var u3, f = "/" !== r2.charAt(1), h = r2.startsWith("<!--"), p = s3 + r2.length, d = e2.charAt(p);
+    if (h) {
+      var v = n(r2);
+      return l < 0 ? (c2.push(v), c2) : ((u3 = o[l]).children.push(v), c2);
+    }
+    if (f && (l++, "tag" === (a2 = n(r2)).type && t2.components[a2.name] && (a2.type = "component", m = true), a2.voidElement || m || !d || "<" === d || a2.children.push({ type: "text", content: e2.slice(p, e2.indexOf("<", p)) }), 0 === l && c2.push(a2), (u3 = o[l - 1]) && u3.children.push(a2), o[l] = a2), (!f || a2.voidElement) && (l > -1 && (a2.voidElement || a2.name === r2.slice(2, -1)) && (l--, a2 = -1 === l ? c2 : o[l]), !m && "<" !== d && d)) {
+      u3 = -1 === l ? c2 : o[l].children;
+      var x = e2.indexOf("<", p), g = e2.slice(p, -1 === x ? void 0 : x);
+      i2.test(g) && (g = " "), (x > -1 && l + u3.length >= 0 || " " !== g) && u3.push({ type: "text", content: g });
+    }
+  }), c2;
+}, stringify: function(e2) {
+  return e2.reduce(function(e3, t2) {
+    return e3 + a("", t2);
+  }, "");
+} };
+const hasChildren = (node, checkLength) => {
+  if (!node) return false;
+  const base = node.props?.children ?? node.children;
+  if (checkLength) return base.length > 0;
+  return !!base;
+};
+const getChildren = (node) => {
+  if (!node) return [];
+  const children = node.props?.children ?? node.children;
+  return node.props?.i18nIsDynamicList ? getAsArray(children) : children;
+};
+const hasValidReactChildren = (children) => Array.isArray(children) && children.every(isValidElement);
+const getAsArray = (data) => Array.isArray(data) ? data : [data];
+const mergeProps = (source, target) => {
+  const newTarget = {
+    ...target
+  };
+  newTarget.props = Object.assign(source.props, target.props);
+  return newTarget;
+};
+const nodesToString = (children, i18nOptions, i18n, i18nKey) => {
+  if (!children) return "";
+  let stringNode = "";
+  const childrenArray = getAsArray(children);
+  const keepArray = i18nOptions?.transSupportBasicHtmlNodes ? i18nOptions.transKeepBasicHtmlNodesFor ?? [] : [];
+  childrenArray.forEach((child, childIndex) => {
+    if (isString(child)) {
+      stringNode += `${child}`;
+      return;
+    }
+    if (isValidElement(child)) {
+      const {
+        props,
+        type
+      } = child;
+      const childPropsCount = Object.keys(props).length;
+      const shouldKeepChild = keepArray.indexOf(type) > -1;
+      const childChildren = props.children;
+      if (!childChildren && shouldKeepChild && !childPropsCount) {
+        stringNode += `<${type}/>`;
+        return;
+      }
+      if (!childChildren && (!shouldKeepChild || childPropsCount) || props.i18nIsDynamicList) {
+        stringNode += `<${childIndex}></${childIndex}>`;
+        return;
+      }
+      if (shouldKeepChild && childPropsCount === 1 && isString(childChildren)) {
+        stringNode += `<${type}>${childChildren}</${type}>`;
+        return;
+      }
+      const content = nodesToString(childChildren, i18nOptions, i18n, i18nKey);
+      stringNode += `<${childIndex}>${content}</${childIndex}>`;
+      return;
+    }
+    if (child === null) {
+      warn(i18n, "TRANS_NULL_VALUE", `Passed in a null value as child`, {
+        i18nKey
+      });
+      return;
+    }
+    if (isObject(child)) {
+      const {
+        format,
+        ...clone
+      } = child;
+      const keys = Object.keys(clone);
+      if (keys.length === 1) {
+        const value = format ? `${keys[0]}, ${format}` : keys[0];
+        stringNode += `{{${value}}}`;
+        return;
+      }
+      warn(i18n, "TRANS_INVALID_OBJ", `Invalid child - Object should only have keys {{ value, format }} (format is optional).`, {
+        i18nKey,
+        child
+      });
+      return;
+    }
+    warn(i18n, "TRANS_INVALID_VAR", `Passed in a variable like {number} - pass variables for interpolation as full objects like {{number}}.`, {
+      i18nKey,
+      child
+    });
+  });
+  return stringNode;
+};
+const renderNodes = (children, targetString, i18n, i18nOptions, combinedTOpts, shouldUnescape) => {
+  if (targetString === "") return [];
+  const keepArray = i18nOptions.transKeepBasicHtmlNodesFor || [];
+  const emptyChildrenButNeedsHandling = targetString && new RegExp(keepArray.map((keep) => `<${keep}`).join("|")).test(targetString);
+  if (!children && !emptyChildrenButNeedsHandling && !shouldUnescape) return [targetString];
+  const data = {};
+  const getData = (childs) => {
+    const childrenArray = getAsArray(childs);
+    childrenArray.forEach((child) => {
+      if (isString(child)) return;
+      if (hasChildren(child)) getData(getChildren(child));
+      else if (isObject(child) && !isValidElement(child)) Object.assign(data, child);
+    });
+  };
+  getData(children);
+  const ast = c.parse(`<0>${targetString}</0>`);
+  const opts = {
+    ...data,
+    ...combinedTOpts
+  };
+  const renderInner = (child, node, rootReactNode) => {
+    const childs = getChildren(child);
+    const mappedChildren = mapAST(childs, node.children, rootReactNode);
+    return hasValidReactChildren(childs) && mappedChildren.length === 0 || child.props?.i18nIsDynamicList ? childs : mappedChildren;
+  };
+  const pushTranslatedJSX = (child, inner, mem, i3, isVoid) => {
+    if (child.dummy) {
+      child.children = inner;
+      mem.push(cloneElement(child, {
+        key: i3
+      }, isVoid ? void 0 : inner));
+    } else {
+      mem.push(...Children.map([child], (c2) => {
+        const props = {
+          ...c2.props
+        };
+        delete props.i18nIsDynamicList;
+        return createElement(c2.type, {
+          ...props,
+          key: i3,
+          ref: c2.ref
+        }, isVoid ? null : inner);
+      }));
+    }
+  };
+  const mapAST = (reactNode, astNode, rootReactNode) => {
+    const reactNodes = getAsArray(reactNode);
+    const astNodes = getAsArray(astNode);
+    return astNodes.reduce((mem, node, i3) => {
+      const translationContent = node.children?.[0]?.content && i18n.services.interpolator.interpolate(node.children[0].content, opts, i18n.language);
+      if (node.type === "tag") {
+        let tmp = reactNodes[parseInt(node.name, 10)];
+        if (rootReactNode.length === 1 && !tmp) tmp = rootReactNode[0][node.name];
+        if (!tmp) tmp = {};
+        const child = Object.keys(node.attrs).length !== 0 ? mergeProps({
+          props: node.attrs
+        }, tmp) : tmp;
+        const isElement = isValidElement(child);
+        const isValidTranslationWithChildren = isElement && hasChildren(node, true) && !node.voidElement;
+        const isEmptyTransWithHTML = emptyChildrenButNeedsHandling && isObject(child) && child.dummy && !isElement;
+        const isKnownComponent = isObject(children) && Object.hasOwnProperty.call(children, node.name);
+        if (isString(child)) {
+          const value = i18n.services.interpolator.interpolate(child, opts, i18n.language);
+          mem.push(value);
+        } else if (hasChildren(child) || isValidTranslationWithChildren) {
+          const inner = renderInner(child, node, rootReactNode);
+          pushTranslatedJSX(child, inner, mem, i3);
+        } else if (isEmptyTransWithHTML) {
+          const inner = mapAST(reactNodes, node.children, rootReactNode);
+          pushTranslatedJSX(child, inner, mem, i3);
+        } else if (Number.isNaN(parseFloat(node.name))) {
+          if (isKnownComponent) {
+            const inner = renderInner(child, node, rootReactNode);
+            pushTranslatedJSX(child, inner, mem, i3, node.voidElement);
+          } else if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {
+            if (node.voidElement) {
+              mem.push(createElement(node.name, {
+                key: `${node.name}-${i3}`
+              }));
+            } else {
+              const inner = mapAST(reactNodes, node.children, rootReactNode);
+              mem.push(createElement(node.name, {
+                key: `${node.name}-${i3}`
+              }, inner));
+            }
+          } else if (node.voidElement) {
+            mem.push(`<${node.name} />`);
+          } else {
+            const inner = mapAST(reactNodes, node.children, rootReactNode);
+            mem.push(`<${node.name}>${inner}</${node.name}>`);
+          }
+        } else if (isObject(child) && !isElement) {
+          const content = node.children[0] ? translationContent : null;
+          if (content) mem.push(content);
+        } else {
+          pushTranslatedJSX(child, translationContent, mem, i3, node.children.length !== 1 || !translationContent);
+        }
+      } else if (node.type === "text") {
+        const wrapTextNodes = i18nOptions.transWrapTextNodes;
+        const content = shouldUnescape ? i18nOptions.unescape(i18n.services.interpolator.interpolate(node.content, opts, i18n.language)) : i18n.services.interpolator.interpolate(node.content, opts, i18n.language);
+        if (wrapTextNodes) {
+          mem.push(createElement(wrapTextNodes, {
+            key: `${node.name}-${i3}`
+          }, content));
+        } else {
+          mem.push(content);
+        }
+      }
+      return mem;
+    }, []);
+  };
+  const result = mapAST([{
+    dummy: true,
+    children: children || []
+  }], ast, getAsArray(children || []));
+  return getChildren(result[0]);
+};
+const fixComponentProps = (component, index, translation) => {
+  const componentKey = component.key || index;
+  const comp = cloneElement(component, {
+    key: componentKey
+  });
+  if (!comp.props || !comp.props.children || translation.indexOf(`${index}/>`) < 0 && translation.indexOf(`${index} />`) < 0) {
+    return comp;
+  }
+  function Componentized() {
+    return createElement(Fragment, null, comp);
+  }
+  return createElement(Componentized);
+};
+const generateArrayComponents = (components, translation) => components.map((c2, index) => fixComponentProps(c2, index, translation));
+const generateObjectComponents = (components, translation) => {
+  const componentMap = {};
+  Object.keys(components).forEach((c2) => {
+    Object.assign(componentMap, {
+      [c2]: fixComponentProps(components[c2], c2, translation)
+    });
+  });
+  return componentMap;
+};
+const generateComponents = (components, translation, i18n, i18nKey) => {
+  if (!components) return null;
+  if (Array.isArray(components)) {
+    return generateArrayComponents(components, translation);
+  }
+  if (isObject(components)) {
+    return generateObjectComponents(components, translation);
+  }
+  warnOnce(i18n, "TRANS_INVALID_COMPONENTS", `<Trans /> "components" prop expects an object or array`, {
+    i18nKey
+  });
+  return null;
+};
+function Trans$1({
+  children,
+  count,
+  parent,
+  i18nKey,
+  context,
+  tOptions = {},
+  values,
+  defaults,
+  components,
+  ns,
+  i18n: i18nFromProps,
+  t: tFromProps,
+  shouldUnescape,
+  ...additionalProps
+}) {
+  const i18n = i18nFromProps || getI18n();
+  if (!i18n) {
+    warnOnce(i18n, "NO_I18NEXT_INSTANCE", `Trans: You need to pass in an i18next instance using i18nextReactModule`, {
+      i18nKey
+    });
+    return children;
+  }
+  const t2 = tFromProps || i18n.t.bind(i18n) || ((k) => k);
+  const reactI18nextOptions = {
+    ...getDefaults(),
+    ...i18n.options?.react
+  };
+  let namespaces = ns || t2.ns || i18n.options?.defaultNS;
+  namespaces = isString(namespaces) ? [namespaces] : namespaces || ["translation"];
+  const nodeAsString = nodesToString(children, reactI18nextOptions, i18n, i18nKey);
+  const defaultValue = defaults || nodeAsString || reactI18nextOptions.transEmptyNodeValue || i18nKey;
+  const {
+    hashTransKey
+  } = reactI18nextOptions;
+  const key = i18nKey || (hashTransKey ? hashTransKey(nodeAsString || defaultValue) : nodeAsString || defaultValue);
+  if (i18n.options?.interpolation?.defaultVariables) {
+    values = values && Object.keys(values).length > 0 ? {
+      ...values,
+      ...i18n.options.interpolation.defaultVariables
+    } : {
+      ...i18n.options.interpolation.defaultVariables
+    };
+  }
+  const interpolationOverride = values || count !== void 0 && !i18n.options?.interpolation?.alwaysFormat || !children ? tOptions.interpolation : {
+    interpolation: {
+      ...tOptions.interpolation,
+      prefix: "#$?",
+      suffix: "?$#"
+    }
+  };
+  const combinedTOpts = {
+    ...tOptions,
+    context: context || tOptions.context,
+    count,
+    ...values,
+    ...interpolationOverride,
+    defaultValue,
+    ns: namespaces
+  };
+  const translation = key ? t2(key, combinedTOpts) : defaultValue;
+  const generatedComponents = generateComponents(components, translation, i18n, i18nKey);
+  const content = renderNodes(generatedComponents || children, translation, i18n, reactI18nextOptions, combinedTOpts, shouldUnescape);
+  const useAsParent = parent ?? reactI18nextOptions.defaultTransParent;
+  return useAsParent ? createElement(useAsParent, additionalProps, content) : content;
+}
+function Trans({
+  children,
+  count,
+  parent,
+  i18nKey,
+  context,
+  tOptions = {},
+  values,
+  defaults,
+  components,
+  ns,
+  i18n: i18nFromProps,
+  t: tFromProps,
+  shouldUnescape,
+  ...additionalProps
+}) {
+  const {
+    i18n: i18nFromContext,
+    defaultNS: defaultNSFromContext
+  } = useContext(I18nContext) || {};
+  const i18n = i18nFromProps || i18nFromContext || getI18n();
+  const t2 = tFromProps || i18n?.t.bind(i18n);
+  return Trans$1({
+    children,
+    count,
+    parent,
+    i18nKey,
+    context,
+    tOptions,
+    values,
+    defaults,
+    components,
+    ns: ns || t2?.ns || defaultNSFromContext || i18n?.options?.defaultNS,
+    i18n,
+    t: tFromProps,
+    shouldUnescape,
+    ...additionalProps
+  });
+}
+export {
+  I18nContext,
+  Trans,
+  Trans$1 as TransWithoutContext,
+  getDefaults,
+  getI18n,
+  i as initReactI18next,
+  s as setDefaults,
+  b as setI18n,
+  u as useTranslation
+};

package/dist/_chunks/index-CCxXsn7Z.js

@@ -0,0 +1,254 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const React__default = /* @__PURE__ */ _interopDefault(React);
+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 strapi = {
+  name: "localazy"
+};
+const pluginPkg = {
+  strapi
+};
+const PLUGIN_ID = pluginPkg.strapi.name;
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(setPlugin);
+  React.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const Localazy = () => {
+  return /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "24", height: "24", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", fill: "#8e8ea9", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M16.4517 2.56643L16.3247 2.87501L15.5632 4.67576H7.49071C7.18595 4.67576 6.98278 4.98434 7.1013 5.26333L9.05259 9.91314C9.12031 10.0695 9.27269 10.171 9.442 10.171H12.6211C12.9216 10.171 13.1247 10.4753 13.0147 10.7501L12.8919 11.046L12.1353 12.8468H10.9192C10.6187 12.8468 10.4113 13.1553 10.5298 13.4343L13.8229 21.2925C13.9626 21.6265 13.7171 21.9942 13.353 21.9942H11.3256C11.1224 21.9942 10.9362 21.8716 10.8557 21.6814L3.1056 3.17091C2.8728 2.61293 3.27915 2 3.88443 2H16.0538C16.3501 2 16.5533 2.29167 16.4517 2.56643Z" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M17.2937 13.5315L21.0354 4.63345C21.2724 4.07548 20.8619 3.45832 20.2566 3.46255L17.2267 3.46255L16.4794 5.23793C16.4794 5.24638 16.4752 5.25484 16.4709 5.26329L16.4709 5.26329L16.3482 5.55074C16.2297 5.82973 16.4371 6.1383 16.7376 6.1383H16.8069C17.1074 6.1383 17.3148 6.44688 17.1963 6.72587L15.2408 11.3757C15.1773 11.5321 15.0207 11.6335 14.8514 11.6335H13.7902L12.9112 13.7217C12.7927 14.0007 13.0001 14.3093 13.3006 14.3093H16.1212C16.6334 14.3093 17.0947 14.0007 17.2937 13.5315Z" })
+  ] });
+};
+const index = {
+  register(app) {
+    addMenuLink(app);
+    addSettingsSection(app);
+    addPlugin(app);
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("./en-CMWcM0nM.js")), "./translations/fr.json": () => Promise.resolve().then(() => require("./fr-C8Qw4iPZ.js")) }), `./translations/${locale}.json`, 3);
+          return { data, locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  },
+  async bootstrap(app) {
+    try {
+      const contentManagerPlugin = app.getPlugin("content-manager");
+      if (contentManagerPlugin?.apis?.addEditViewSidePanel) {
+        const { default: LocalazyPanel } = await Promise.resolve().then(() => require("./LocalazyPanel-BXVLvFgD.js"));
+        const apis = contentManagerPlugin.apis;
+        apis.addEditViewSidePanel([LocalazyPanel]);
+      } else {
+        console.warn('Localazy Plugin: Content Manager "addEditViewSidePanel" API not available');
+      }
+      const { default: LocalazyStatusColumn } = await Promise.resolve().then(() => require("./LocalazyStatusColumn-Dt96YcGQ.js"));
+      app.registerHook("Admin/CM/pages/ListView/inject-column-in-table", (params) => {
+        try {
+          console.log("Localazy: Hook called with params:", params);
+          const { displayedHeaders, layout } = params;
+          if (!Array.isArray(displayedHeaders)) {
+            return params;
+          }
+          const localazyStatusColumn = {
+            name: "localazy_status",
+            label: "Localazy Status",
+            searchable: false,
+            sortable: false,
+            attribute: { type: "custom" },
+            cellFormatter: (data, header, context) => {
+              return React__default.default.createElement(LocalazyStatusColumn, {
+                data,
+                model: context?.model || ""
+              });
+            }
+          };
+          const updatedHeaders = [...displayedHeaders, localazyStatusColumn];
+          return {
+            displayedHeaders: updatedHeaders,
+            layout
+          };
+        } catch (error) {
+          console.error("Localazy: Error in hook:", error);
+          return params;
+        }
+      });
+      if (contentManagerPlugin?.apis?.addBulkAction) {
+        const { useNotification } = await import("@strapi/strapi/admin");
+        await Promise.resolve().then(() => require("./i18n-0dV2P-Hm.js"));
+        const { useTranslation } = await Promise.resolve().then(() => require("./index-1he9s_bs.js"));
+        const ExcludeFromTranslationAction = (props) => {
+          const { documents, model } = props;
+          const { toggleNotification } = useNotification();
+          const { t } = useTranslation();
+          return {
+            label: t("plugin_settings.bulk_action_exclude_from_translation"),
+            variant: "secondary",
+            onClick: async () => {
+              try {
+                toggleNotification({
+                  type: "info",
+                  message: t("plugin_settings.bulk_action_updating_entries")
+                });
+                const { default: EntryExclusionService } = await Promise.resolve().then(() => require("./entry-exclusion-service-CGV6iOkB.js"));
+                const documentIds = documents.map((doc) => doc.documentId);
+                await EntryExclusionService.setMultipleEntriesExclusion(model, documentIds, true);
+                toggleNotification({
+                  type: "success",
+                  message: t("plugin_settings.bulk_action_success_message"),
+                  timeout: 5e3
+                });
+              } catch (error) {
+                console.error("Failed to exclude entries from translation:", error);
+                toggleNotification({
+                  type: "danger",
+                  message: t("plugin_settings.bulk_action_failed_message")
+                });
+              }
+            }
+          };
+        };
+        ExcludeFromTranslationAction.type = "exclude-translation";
+        const IncludeToTranslationAction = ({ documents, model }) => {
+          const { toggleNotification } = useNotification();
+          const { t } = useTranslation();
+          return {
+            label: t("plugin_settings.bulk_action_include_to_translation"),
+            variant: "secondary",
+            onClick: async () => {
+              try {
+                toggleNotification({
+                  type: "info",
+                  message: t("plugin_settings.bulk_action_updating_entries")
+                });
+                const { default: EntryExclusionService } = await Promise.resolve().then(() => require("./entry-exclusion-service-CGV6iOkB.js"));
+                const documentIds = documents.map((doc) => doc.documentId);
+                await EntryExclusionService.setMultipleEntriesExclusion(model, documentIds, false);
+                toggleNotification({
+                  type: "success",
+                  message: t("plugin_settings.bulk_action_success_message"),
+                  timeout: 5e3
+                });
+              } catch (error) {
+                console.error("Failed to include entries to translation:", error);
+                toggleNotification({
+                  type: "danger",
+                  message: t("plugin_settings.bulk_action_failed_message")
+                });
+              }
+            }
+          };
+        };
+        IncludeToTranslationAction.type = "include-translation";
+        contentManagerPlugin.apis.addBulkAction([ExcludeFromTranslationAction, IncludeToTranslationAction]);
+      } else {
+        console.warn('Localazy Plugin: Content Manager "addBulkAction" API not available');
+      }
+    } catch (error) {
+      console.error("Localazy Plugin: Error adding side panel:", error);
+    }
+  }
+};
+const addMenuLink = (app) => {
+  app.addMenuLink({
+    to: `plugins/${PLUGIN_ID}/`,
+    icon: Localazy,
+    intlLabel: {
+      id: `${PLUGIN_ID}.name`,
+      defaultMessage: "Localazy"
+    },
+    Component: () => Promise.resolve().then(() => require("./LocalazyApp-DnaA768k.js"))
+  });
+};
+const addSettingsSection = (app) => {
+  app.addSettingsLink(
+    {
+      id: `${PLUGIN_ID}-settings`,
+      intlLabel: {
+        id: `${PLUGIN_ID}.localazy_settings`,
+        defaultMessage: "Localazy Settings"
+      }
+    },
+    [
+      // General
+      {
+        id: `${PLUGIN_ID}-settings-global`,
+        intlLabel: {
+          id: `${PLUGIN_ID}.localazy_settings`,
+          defaultMessage: "Localazy Settings"
+        },
+        to: `${PLUGIN_ID}/global-settings`,
+        Component: () => Promise.resolve().then(() => require("./LocalazyGlobalSettings-ewETL3oG.js")),
+        permissions: []
+      },
+      // Content Transfer Setup
+      {
+        id: `${PLUGIN_ID}-settings-content-transfer-setup`,
+        intlLabel: {
+          id: `${PLUGIN_ID}.content_transfer_setup`,
+          defaultMessage: "Content Transfer Setup"
+        },
+        to: `${PLUGIN_ID}/content-transfer-setup`,
+        Component: () => Promise.resolve().then(() => require("./LocalazyContentTransferSetup-CeOM6bYA.js")),
+        permissions: []
+      }
+    ]
+  );
+};
+const addPlugin = (app) => {
+  app.registerPlugin({
+    id: PLUGIN_ID,
+    initializer: Initializer,
+    isReady: false,
+    name: PLUGIN_ID
+  });
+};
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.index = index;