@vicacha-devs/strapi-plugin-notes 0.0.0-stage → 1.0.0

package/dist/admin/index-C7es-Q8Z.cjs

@@ -0,0 +1,1551 @@
+"use strict";
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const designSystem = require("@strapi/design-system");
+const icons = require("@strapi/icons");
+const reactIntl = require("react-intl");
+const admin = require("@strapi/strapi/admin");
+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);
+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." : "")
+        )
+      )
+    );
+  });
+};
+function freezeOptions(items) {
+  return Object.freeze(items.map((item) => Object.freeze({ ...item })));
+}
+freezeOptions([
+  { value: "es", label: "es — Español (Spanish)" },
+  { value: "en", label: "en — English" },
+  { value: "ar", label: "ar — العربية (Arabic)" },
+  { value: "tr", label: "tr — Türkçe (Turkish)" },
+  { value: "fr", label: "fr — Français (French)" },
+  { value: "de", label: "de — Deutsch (German)" },
+  { value: "pt", label: "pt — Português (Portuguese)" },
+  { value: "it", label: "it — Italiano (Italian)" },
+  { value: "nl", label: "nl — Nederlands (Dutch)" },
+  { value: "pl", label: "pl — Polski (Polish)" },
+  { value: "ru", label: "ru — Русский (Russian)" },
+  { value: "id", label: "id — Bahasa Indonesia" },
+  { value: "ur", label: "ur — اردو (Urdu)" },
+  { value: "zh", label: "zh — 中文 (Chinese)" }
+]);
+freezeOptions([
+  {
+    value: "islamic-umalqura",
+    label: "islamic-umalqura (Hijri Umm al-Qura)"
+  },
+  { value: "islamic-civil", label: "islamic-civil (Tabular Islamic Civil)" },
+  { value: "islamic-tbla", label: "islamic-tbla (Tabular Astronomical)" },
+  { value: "hebrew", label: "hebrew (Hebrew)" },
+  { value: "persian", label: "persian (Solar Hijri)" },
+  { value: "none", label: "none (Gregorian Only)" }
+]);
+const VALID_LOCALE_RE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,4}$/;
+function isTranslationRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function extractDictionary(loaded) {
+  if (!isTranslationRecord(loaded)) {
+    return void 0;
+  }
+  if ("default" in loaded) {
+    return isTranslationRecord(loaded.default) ? loaded.default : void 0;
+  }
+  return loaded;
+}
+function getLookupCandidates(locale, fallbackToLanguage) {
+  const trimmed = locale.trim();
+  if (!VALID_LOCALE_RE.test(trimmed)) {
+    return [];
+  }
+  if (!fallbackToLanguage || !trimmed.includes("-")) {
+    return [trimmed];
+  }
+  const base = trimmed.split("-")[0];
+  return base && base !== trimmed ? [trimmed, base] : [trimmed];
+}
+function prefixPluginTranslations(trad, pluginId, options) {
+  const normalizedPluginId = typeof pluginId === "string" ? pluginId.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const result = {};
+  if (options?.baseTranslations) {
+    for (const [key, value] of Object.entries(options.baseTranslations)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+  }
+  const prefix = `${normalizedPluginId}.`;
+  const explicitPrefixed = [];
+  for (const [key, value] of Object.entries(trad)) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    if (options?.keepUnprefixed) {
+      result[key] = value;
+    }
+    if (key.startsWith(prefix)) {
+      explicitPrefixed.push([key, value]);
+    } else {
+      result[`${prefix}${key}`] = value;
+    }
+  }
+  for (const [key, value] of explicitPrefixed) {
+    result[key] = value;
+  }
+  return result;
+}
+function createRegisterTrads(options) {
+  const { pluginId, defaultLocales = ["en", "es", "ar", "tr"], supportedLocales, keepUnprefixed = true, fallbackToLanguageCode = true, loadTranslation, translations, getBaseTranslations, onLoaded } = options;
+  const normalizedPluginId = typeof pluginId === "string" ? pluginId.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const supportedSet = supportedLocales ? new Set(supportedLocales) : void 0;
+  const effectiveDefaults = supportedSet ? defaultLocales.filter((loc) => getLookupCandidates(loc, fallbackToLanguageCode).some((candidate) => supportedSet.has(candidate))) : defaultLocales;
+  return async function registerTrads({ locales = [] } = {}) {
+    const allLocales = effectiveDefaults.length > 0 ? Array.from(/* @__PURE__ */ new Set([...locales, ...effectiveDefaults])) : Array.from(new Set(locales));
+    return Promise.all(allLocales.map(async (locale) => {
+      const candidates = getLookupCandidates(locale, fallbackToLanguageCode);
+      if (candidates.length === 0) {
+        return { data: {}, locale };
+      }
+      if (supportedSet && !candidates.some((candidate) => supportedSet.has(candidate))) {
+        return { data: {}, locale };
+      }
+      let rawData;
+      for (const candidate of candidates) {
+        if (translations && Object.hasOwn(translations, candidate)) {
+          rawData = extractDictionary(translations[candidate]);
+          if (rawData) {
+            break;
+          }
+        }
+        if (loadTranslation) {
+          try {
+            const loaded = await loadTranslation(candidate);
+            rawData = extractDictionary(loaded);
+            if (rawData) {
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      const baseTranslations = getBaseTranslations?.(locale);
+      const hasBase = Boolean(baseTranslations) && Object.keys(baseTranslations).length > 0;
+      if (!rawData && !hasBase) {
+        return { data: {}, locale };
+      }
+      const prefixed = prefixPluginTranslations(rawData ?? {}, normalizedPluginId, {
+        keepUnprefixed,
+        baseTranslations
+      });
+      onLoaded?.(locale, prefixed);
+      return { data: prefixed, locale };
+    }));
+  };
+}
+const PLUGIN_ID = "notes";
+const NOTE_CATEGORIES = ["general", "todo", "blocker", "idea"];
+const MAX_NOTE_TITLE_LENGTH = 255;
+const MAX_NOTE_CONTENT_LENGTH = 2e4;
+const MAX_ENTITY_SLUG_LENGTH = 160;
+const MAX_ENTITY_ID_LENGTH = 128;
+const MAX_LOCALE_LENGTH = 32;
+const NOTE_CATEGORY_META = {
+  general: {
+    labelKey: "category.general",
+    defaultLabel: "General",
+    badgeBackground: "neutral150",
+    badgeTextColor: "neutral800"
+  },
+  todo: {
+    labelKey: "category.todo",
+    defaultLabel: "Todo",
+    badgeBackground: "primary100",
+    badgeTextColor: "primary700"
+  },
+  blocker: {
+    labelKey: "category.blocker",
+    defaultLabel: "Blocker",
+    badgeBackground: "danger100",
+    badgeTextColor: "danger700"
+  },
+  idea: {
+    labelKey: "category.idea",
+    defaultLabel: "Idea",
+    badgeBackground: "success100",
+    badgeTextColor: "success700"
+  }
+};
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(setPlugin);
+  React.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const ENTITY_SLUG_PATTERN = /^[a-zA-Z0-9_:.-]{1,160}$/;
+const SAFE_ID_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;
+const LOCALE_PATTERN = /^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8}){0,4}$/;
+const FORBIDDEN_IDENTIFIER_TOKENS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isForbiddenIdentifier(value) {
+  const lower = value.toLowerCase();
+  if (FORBIDDEN_IDENTIFIER_TOKENS.has(lower)) return true;
+  if (value === "." || value === ".." || value.includes("..") || value.startsWith(".") || value.endsWith(".")) {
+    return true;
+  }
+  return lower.split(/[:./]+/).some((segment) => FORBIDDEN_IDENTIFIER_TOKENS.has(segment));
+}
+function toPositiveSafeInt(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) return null;
+  const truncated = Math.trunc(input);
+  return Number.isSafeInteger(truncated) && truncated >= 1 ? truncated : null;
+}
+function isValidNoteCategory(value) {
+  return typeof value === "string" && NOTE_CATEGORIES.includes(value);
+}
+function normalizeNoteCategory(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (isValidNoteCategory(normalized)) return normalized;
+  }
+  return "general";
+}
+function sanitizePlainText(input, maxLength) {
+  if (typeof input !== "string") return "";
+  const cleaned = input.replace(/\0/g, "").replace(/\r\n/g, "\n").trim();
+  return cleaned.length > maxLength ? cleaned.slice(0, maxLength) : cleaned;
+}
+function sanitizeEntitySlug(input) {
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_SLUG_LENGTH || isForbiddenIdentifier(cleaned) || !ENTITY_SLUG_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function sanitizeEntityDocumentId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) return String(numeric);
+  if (typeof input !== "string" || input.includes("\0")) return "";
+  const cleaned = input.trim();
+  if (!cleaned || cleaned.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(cleaned) || !SAFE_ID_PATTERN.test(cleaned)) {
+    return "";
+  }
+  return cleaned;
+}
+function parseStringEntityId(input) {
+  if (input.includes("\0")) return null;
+  const trimmed = input.trim();
+  if (!trimmed || trimmed.length > MAX_ENTITY_ID_LENGTH || isForbiddenIdentifier(trimmed)) {
+    return null;
+  }
+  if (/^\d+$/.test(trimmed)) {
+    const parsed = Number.parseInt(trimmed, 10);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null;
+  }
+  return SAFE_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function sanitizeEntityId(input) {
+  const numeric = toPositiveSafeInt(input);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof input === "string") {
+    return parseStringEntityId(input);
+  }
+  return null;
+}
+function isWildcardOrInvalidLocale(cleaned) {
+  if (!cleaned || cleaned === "all" || cleaned === "*") {
+    return true;
+  }
+  return cleaned.length > MAX_LOCALE_LENGTH || isForbiddenIdentifier(cleaned);
+}
+function sanitizeEntityLocale(input) {
+  if (typeof input !== "string" || input.includes("\0")) {
+    return null;
+  }
+  const cleaned = input.trim();
+  if (isWildcardOrInvalidLocale(cleaned)) {
+    return null;
+  }
+  return LOCALE_PATTERN.test(cleaned) ? cleaned : null;
+}
+function extractPrimitiveAuthorId(rawUser) {
+  const numeric = toPositiveSafeInt(rawUser);
+  if (numeric !== null) {
+    return numeric;
+  }
+  if (typeof rawUser === "string" && rawUser.trim()) {
+    return sanitizeEntityDocumentId(rawUser) || null;
+  }
+  return null;
+}
+function sanitizePrimitiveAuthor(rawUser, fallback) {
+  const primitiveId = extractPrimitiveAuthorId(rawUser);
+  if (!fallback && primitiveId === null) {
+    return null;
+  }
+  return {
+    id: primitiveId,
+    firstname: "",
+    lastname: "",
+    username: "",
+    displayName: fallback || `#${String(primitiveId)}`
+  };
+}
+function asPlainObject(value, fallback) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : fallback;
+}
+function unwrapAuthorRecord(rawUser) {
+  const nestedData = asPlainObject(rawUser.data, rawUser);
+  const attrs = asPlainObject(nestedData.attributes, nestedData);
+  const id = extractPrimitiveAuthorId(nestedData.id ?? rawUser.id);
+  return { attrs, id };
+}
+function sanitizeNoteAuthor(rawUser, fallbackDisplayName) {
+  const fallback = sanitizePlainText(fallbackDisplayName, 120);
+  if (!rawUser || typeof rawUser !== "object" || Array.isArray(rawUser)) {
+    return sanitizePrimitiveAuthor(rawUser, fallback);
+  }
+  const { attrs, id } = unwrapAuthorRecord(rawUser);
+  const firstname = sanitizePlainText(attrs.firstname, 80);
+  const lastname = sanitizePlainText(attrs.lastname, 80);
+  const username = sanitizePlainText(attrs.username, 80);
+  const explicitDisplayName = sanitizePlainText(attrs.displayName, 120);
+  const fullName = [firstname, lastname].filter(Boolean).join(" ").trim();
+  const displayName = fullName || username || explicitDisplayName || fallback || "";
+  if (!displayName && id === null) {
+    return null;
+  }
+  return {
+    id,
+    firstname,
+    lastname,
+    username,
+    displayName: displayName || `#${String(id)}`
+  };
+}
+function formatNoteAuthorDisplay(author, emptyFallback = "-") {
+  if (!author) {
+    return emptyFallback;
+  }
+  const fullName = [author.firstname, author.lastname].filter(Boolean).join(" ").trim();
+  if (fullName) {
+    return fullName;
+  }
+  if (author.username && author.username.trim()) {
+    return author.username.trim();
+  }
+  if (author.displayName && author.displayName.trim()) {
+    return author.displayName.trim();
+  }
+  return emptyFallback;
+}
+function formatNoteTimestamp(isoString, locale = "en", emptyFallback = "-") {
+  if (!isoString || typeof isoString !== "string") {
+    return emptyFallback;
+  }
+  const date = new Date(isoString);
+  if (Number.isNaN(date.getTime())) {
+    return emptyFallback;
+  }
+  try {
+    return new Intl.DateTimeFormat(locale || "en", {
+      dateStyle: "medium",
+      timeStyle: "short"
+    }).format(date);
+  } catch {
+    return date.toISOString();
+  }
+}
+function extractRecordId(root, attrs) {
+  if (typeof root.id === "number" && Number.isFinite(root.id) || typeof root.id === "string") {
+    return root.id;
+  }
+  if (typeof attrs.id === "number" && Number.isFinite(attrs.id) || typeof attrs.id === "string") {
+    return attrs.id;
+  }
+  return "";
+}
+function sanitizeOptionalIsoString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function unwrapRawNoteAttributes(raw) {
+  const root = asPlainObject(raw, {});
+  const rawAttrs = asPlainObject(root.attributes, {});
+  const attrs = { ...root, ...rawAttrs };
+  return { root, attrs };
+}
+function normalizeNoteRecord(raw) {
+  const { root, attrs } = unwrapRawNoteAttributes(raw);
+  const id = extractRecordId(root, attrs);
+  const documentId = sanitizeEntityDocumentId(root.documentId ?? attrs.documentId) || String(id || "");
+  const entityId = sanitizeEntityId(attrs.entityId);
+  const entityDocumentId = sanitizeEntityDocumentId(attrs.entityDocumentId) || (entityId !== null ? String(entityId) : "");
+  const createdBy = sanitizeNoteAuthor(
+    attrs.createdBy,
+    attrs.createdByName ?? attrs.authorName
+  );
+  const updatedBy = sanitizeNoteAuthor(attrs.updatedBy, attrs.updatedByName) ?? createdBy;
+  const createdAt = sanitizeOptionalIsoString(attrs.createdAt);
+  const updatedAt = sanitizeOptionalIsoString(attrs.updatedAt) ?? createdAt;
+  const normalizedAttributes = {
+    title: sanitizePlainText(attrs.title, MAX_NOTE_TITLE_LENGTH),
+    content: sanitizePlainText(attrs.content, MAX_NOTE_CONTENT_LENGTH),
+    category: normalizeNoteCategory(attrs.category),
+    isPinned: Boolean(attrs.isPinned),
+    entitySlug: sanitizeEntitySlug(attrs.entitySlug),
+    entityId,
+    entityDocumentId,
+    entityLocale: sanitizeEntityLocale(attrs.entityLocale),
+    createdAt,
+    updatedAt,
+    createdBy,
+    updatedBy
+  };
+  return {
+    id,
+    documentId,
+    ...normalizedAttributes,
+    attributes: normalizedAttributes
+  };
+}
+function sortNotesPinnedFirst(notes, direction = "DESC") {
+  return [...notes].sort((a, b) => {
+    if (a.isPinned !== b.isPinned) {
+      return a.isPinned ? -1 : 1;
+    }
+    const timeA = a.createdAt ? Date.parse(a.createdAt) : 0;
+    const timeB = b.createdAt ? Date.parse(b.createdAt) : 0;
+    if (timeA !== timeB && !Number.isNaN(timeA) && !Number.isNaN(timeB)) {
+      return direction === "ASC" ? timeA - timeB : timeB - timeA;
+    }
+    return String(a.id).localeCompare(String(b.id));
+  });
+}
+function matchesEntityIdentifier(note, docIdFilter, entityIdFilter) {
+  if (!docIdFilter && entityIdFilter === null) {
+    return true;
+  }
+  const noteIdStr = note.entityId !== null ? String(note.entityId) : "";
+  if (docIdFilter) {
+    if (note.entityDocumentId === docIdFilter || noteIdStr === docIdFilter) {
+      return true;
+    }
+  }
+  if (entityIdFilter !== null) {
+    const filterStr = String(entityIdFilter);
+    if (noteIdStr === filterStr || note.entityDocumentId === filterStr) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesLocaleFilter(note, localeFilter, includeAllLocales) {
+  if (!localeFilter || includeAllLocales) {
+    return true;
+  }
+  return !note.entityLocale || note.entityLocale === localeFilter;
+}
+function matchesSearchFilter(note, searchFilter) {
+  if (!searchFilter) {
+    return true;
+  }
+  const haystack = [
+    note.title,
+    note.content,
+    note.entitySlug,
+    note.createdBy?.displayName ?? "",
+    note.updatedBy?.displayName ?? ""
+  ].join(" ").toLowerCase();
+  return haystack.includes(searchFilter);
+}
+function matchesAllNoteFilters(note, filters) {
+  if (filters.slugFilter && note.entitySlug !== filters.slugFilter) {
+    return false;
+  }
+  if (!matchesEntityIdentifier(note, filters.docIdFilter, filters.entityIdFilter)) {
+    return false;
+  }
+  if (!matchesLocaleFilter(note, filters.localeFilter, filters.includeAllLocales)) {
+    return false;
+  }
+  if (filters.categoryFilter && note.category !== filters.categoryFilter) {
+    return false;
+  }
+  if (typeof filters.isPinned === "boolean" && note.isPinned !== filters.isPinned) {
+    return false;
+  }
+  return matchesSearchFilter(note, filters.searchFilter);
+}
+function filterNotesList(notes, params = {}) {
+  const filters = {
+    slugFilter: params.entitySlug ? sanitizeEntitySlug(params.entitySlug) : "",
+    docIdFilter: params.entityDocumentId ? sanitizeEntityDocumentId(params.entityDocumentId) : "",
+    entityIdFilter: params.entityId !== void 0 && params.entityId !== null ? sanitizeEntityId(params.entityId) : null,
+    localeFilter: sanitizeEntityLocale(params.entityLocale),
+    includeAllLocales: params.includeAllLocales,
+    categoryFilter: params.category && params.category !== "all" ? normalizeNoteCategory(params.category) : null,
+    isPinned: params.isPinned,
+    searchFilter: sanitizePlainText(params.search, 160).toLowerCase()
+  };
+  const filtered = notes.filter((note) => matchesAllNoteFilters(note, filters));
+  const sorted = sortNotesPinnedFirst(filtered, params.sort ?? "DESC");
+  const offset = typeof params.offset === "number" && Number.isFinite(params.offset) && params.offset > 0 ? Math.trunc(params.offset) : 0;
+  const limit = typeof params.limit === "number" && Number.isFinite(params.limit) && params.limit > 0 ? Math.trunc(params.limit) : void 0;
+  if (offset > 0 || limit !== void 0) {
+    return sorted.slice(
+      offset,
+      limit !== void 0 ? offset + limit : void 0
+    );
+  }
+  return sorted;
+}
+function computeNotesSummaryStats(notes) {
+  const byCategory = {
+    general: 0,
+    todo: 0,
+    blocker: 0,
+    idea: 0
+  };
+  let pinned = 0;
+  const slugSet = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    if (note.isPinned) {
+      pinned += 1;
+    }
+    const cat = normalizeNoteCategory(note.category);
+    byCategory[cat] += 1;
+    if (note.entitySlug) {
+      slugSet.add(note.entitySlug);
+    }
+  }
+  return {
+    total: notes.length,
+    pinned,
+    byCategory,
+    entitySlugs: Array.from(slugSet).sort()
+  };
+}
+function buildContentManagerNoteLink(note) {
+  const slug = sanitizeEntitySlug(note.entitySlug);
+  const targetId = sanitizeEntityDocumentId(note.entityDocumentId) || (note.entityId !== null && note.entityId !== void 0 ? sanitizeEntityDocumentId(String(note.entityId)) : "");
+  const isSingleType = note.collectionType === "single-types" || note.collectionType === "singleType" || targetId === "single";
+  if (!slug || !isSingleType && !targetId) {
+    return null;
+  }
+  const basePath = isSingleType ? `/content-manager/single-types/${encodeURIComponent(slug)}` : `/content-manager/collection-types/${encodeURIComponent(
+    slug
+  )}/${encodeURIComponent(targetId)}`;
+  const locale = sanitizeEntityLocale(note.entityLocale);
+  if (locale) {
+    return `${basePath}?plugins[i18n][locale]=${encodeURIComponent(locale)}`;
+  }
+  return basePath;
+}
+const getTrad = (id) => `${PLUGIN_ID}.${id}`;
+function formatEntityIdParam(entityId) {
+  if (entityId === void 0 || entityId === null || entityId === "") {
+    return "";
+  }
+  return String(entityId);
+}
+function formatOptionalIntParam(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? String(Math.trunc(value)) : void 0;
+}
+function buildNotesQueryString(params = {}) {
+  const entries = [
+    ["entitySlug", params.entitySlug],
+    ["entityDocumentId", params.entityDocumentId],
+    ["entityId", formatEntityIdParam(params.entityId)],
+    ["entityLocale", params.entityLocale ?? void 0],
+    ["includeAllLocales", params.includeAllLocales ? "true" : void 0],
+    [
+      "category",
+      params.category && params.category !== "all" ? params.category : void 0
+    ],
+    [
+      "isPinned",
+      typeof params.isPinned === "boolean" ? String(params.isPinned) : void 0
+    ],
+    ["search", params.search],
+    ["sort", params.sort],
+    ["limit", formatOptionalIntParam(params.limit)],
+    ["offset", formatOptionalIntParam(params.offset)]
+  ];
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of entries) {
+    if (value) {
+      searchParams.set(key, value);
+    }
+  }
+  const qs = searchParams.toString();
+  return qs ? `?${qs}` : "";
+}
+function matchesNoteIdentifier(note, targetId) {
+  const cleanTarget = String(targetId);
+  return String(note.id) === cleanTarget || String(note.documentId) === cleanTarget;
+}
+function useNotes(initialParams = {}) {
+  const { get, post, put, del } = admin.useFetchClient();
+  const { toggleNotification } = admin.useNotification();
+  const { formatMessage } = reactIntl.useIntl();
+  const [notes, setNotes] = React.useState([]);
+  const [summary, setSummary] = React.useState(
+    () => computeNotesSummaryStats([])
+  );
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [isMutating, setIsMutating] = React.useState(false);
+  const requestIdRef = React.useRef(0);
+  const pendingMutationsRef = React.useRef(0);
+  const notesRef = React.useRef([]);
+  const beginMutation = React.useCallback(() => {
+    pendingMutationsRef.current += 1;
+    setIsMutating(true);
+  }, []);
+  const endMutation = React.useCallback(() => {
+    pendingMutationsRef.current = Math.max(0, pendingMutationsRef.current - 1);
+    if (pendingMutationsRef.current === 0) {
+      setIsMutating(false);
+    }
+  }, []);
+  const t = React.useCallback(
+    (id, defaultMessage) => formatMessage({ id: getTrad(id), defaultMessage }),
+    [formatMessage]
+  );
+  const applyLocalNotesState = React.useCallback(
+    (updater) => {
+      const next = sortNotesPinnedFirst(
+        updater(notesRef.current),
+        initialParams.sort ?? "DESC"
+      );
+      notesRef.current = next;
+      setNotes(next);
+      setSummary(computeNotesSummaryStats(next));
+    },
+    [initialParams.sort]
+  );
+  const fetchNotes = React.useCallback(
+    async (overrideParams) => {
+      const requestId = ++requestIdRef.current;
+      const merged = { ...initialParams, ...overrideParams };
+      setIsLoading(true);
+      try {
+        const qs = buildNotesQueryString(merged);
+        const res = await get(`/${PLUGIN_ID}/notes${qs}`);
+        const rawItems = Array.isArray(res?.data?.data) ? res.data.data : [];
+        const normalized = rawItems.map((item) => normalizeNoteRecord(item));
+        if (requestId === requestIdRef.current) {
+          notesRef.current = normalized;
+          setNotes(normalized);
+          setSummary(
+            res?.data?.meta?.summary ?? computeNotesSummaryStats(normalized)
+          );
+        }
+        return normalized;
+      } catch {
+        if (requestId === requestIdRef.current) {
+          toggleNotification({
+            type: "warning",
+            message: t("notes.notification.loadError", "Unable to load notes.")
+          });
+        }
+        return [];
+      } finally {
+        if (requestId === requestIdRef.current) {
+          setIsLoading(false);
+        }
+      }
+    },
+    [
+      get,
+      initialParams.category,
+      initialParams.entityDocumentId,
+      initialParams.entityId,
+      initialParams.entityLocale,
+      initialParams.entitySlug,
+      initialParams.includeAllLocales,
+      initialParams.isPinned,
+      initialParams.limit,
+      initialParams.offset,
+      initialParams.search,
+      initialParams.sort,
+      t,
+      toggleNotification
+    ]
+  );
+  React.useEffect(() => {
+    void fetchNotes();
+    return () => {
+      requestIdRef.current += 1;
+    };
+  }, [fetchNotes]);
+  const createNote = React.useCallback(
+    async (payload) => {
+      beginMutation();
+      try {
+        const res = await post(`/${PLUGIN_ID}/notes`, {
+          data: payload
+        });
+        const created = res?.data?.data ? normalizeNoteRecord(res.data.data) : null;
+        if (created) {
+          applyLocalNotesState((prev) => [created, ...prev]);
+        }
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.created",
+            "Note has been successfully created."
+          )
+        });
+        await fetchNotes();
+        return created;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.createError",
+            "Failed to create note."
+          )
+        });
+        return null;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      endMutation,
+      fetchNotes,
+      post,
+      t,
+      toggleNotification
+    ]
+  );
+  const updateNote = React.useCallback(
+    async (id, body) => {
+      beginMutation();
+      try {
+        const res = await put(
+          `/${PLUGIN_ID}/notes/${encodeURIComponent(String(id))}`,
+          { data: body }
+        );
+        const updated = res?.data?.data ? normalizeNoteRecord(res.data.data) : null;
+        if (updated) {
+          applyLocalNotesState(
+            (prev) => prev.map(
+              (item) => matchesNoteIdentifier(item, id) ? updated : item
+            )
+          );
+        }
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.updated",
+            "Note has been successfully updated."
+          )
+        });
+        await fetchNotes();
+        return updated;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.updateError",
+            "Failed to update note."
+          )
+        });
+        return null;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      endMutation,
+      fetchNotes,
+      put,
+      t,
+      toggleNotification
+    ]
+  );
+  const deleteNote = React.useCallback(
+    async (id) => {
+      beginMutation();
+      try {
+        await del(`/${PLUGIN_ID}/notes/${encodeURIComponent(String(id))}`);
+        applyLocalNotesState(
+          (prev) => prev.filter((item) => !matchesNoteIdentifier(item, id))
+        );
+        toggleNotification({
+          type: "success",
+          message: t(
+            "notes.notification.deleted",
+            "Note has been successfully deleted."
+          )
+        });
+        await fetchNotes();
+        return true;
+      } catch {
+        toggleNotification({
+          type: "warning",
+          message: t(
+            "notes.notification.deleteError",
+            "Failed to delete note."
+          )
+        });
+        return false;
+      } finally {
+        endMutation();
+      }
+    },
+    [
+      applyLocalNotesState,
+      beginMutation,
+      del,
+      endMutation,
+      fetchNotes,
+      t,
+      toggleNotification
+    ]
+  );
+  return {
+    notes,
+    summary,
+    isLoading,
+    isMutating,
+    refetch: fetchNotes,
+    createNote,
+    updateNote,
+    deleteNote
+  };
+}
+const DeleteNoteDialog = ({
+  note,
+  isSubmitting = false,
+  onCancel,
+  onConfirm
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  if (!note) {
+    return null;
+  }
+  const t = (id, defaultMessage, values) => formatMessage({ id: getTrad(id), defaultMessage }, values);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Dialog.Root,
+    {
+      open: Boolean(note),
+      onOpenChange: (open) => !open && onCancel(),
+      children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Dialog.Content, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Header, { children: t("note.delete.dialog.title", "Confirmation") }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Body, { icon: /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, {}), children: t(
+          "note.delete.dialog.description",
+          'Are you sure you want to delete the note "{title}"?',
+          { title: note.title }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Dialog.Footer, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Cancel, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { fullWidth: true, variant: "tertiary", onClick: onCancel, children: t("note.modal.actions.cancel", "Cancel") }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Dialog.Action, { children: /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.Button,
+            {
+              fullWidth: true,
+              variant: "danger-light",
+              startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {}),
+              loading: isSubmitting,
+              disabled: isSubmitting,
+              onClick: () => onConfirm(note),
+              children: t("note.delete.dialog.confirm", "Confirm")
+            }
+          ) })
+        ] })
+      ] })
+    }
+  );
+};
+const NoteListItem = ({
+  note,
+  onEdit,
+  onRequestDelete,
+  onTogglePin
+}) => {
+  const { formatMessage, locale } = reactIntl.useIntl();
+  const t = (id, defaultMessage) => formatMessage({ id: getTrad(id), defaultMessage });
+  const categoryMeta = NOTE_CATEGORY_META[note.category] ?? NOTE_CATEGORY_META.general;
+  const authorLabel = formatNoteAuthorDisplay(
+    note.updatedBy ?? note.createdBy,
+    ""
+  );
+  const timestampLabel = formatNoteTimestamp(
+    note.updatedAt ?? note.createdAt,
+    locale,
+    ""
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Box,
+    {
+      hasRadius: true,
+      padding: 3,
+      background: "neutral0",
+      borderStyle: "solid",
+      borderWidth: "1px",
+      borderColor: note.isPinned ? "primary600" : "neutral150",
+      shadow: "tableShadow",
+      tag: "article",
+      children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, justifyContent: "space-between", alignItems: "center", children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, alignItems: "center", style: { minWidth: 0, flex: 1 }, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Badge,
+              {
+                backgroundColor: categoryMeta.badgeBackground,
+                textColor: categoryMeta.badgeTextColor,
+                children: t(categoryMeta.labelKey, categoryMeta.defaultLabel)
+              }
+            ),
+            note.entityLocale && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "neutral100", textColor: "neutral700", children: note.entityLocale.toUpperCase() }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Typography,
+              {
+                variant: "pi",
+                textColor: "neutral800",
+                fontWeight: "bold",
+                ellipsis: true,
+                role: "button",
+                tabIndex: 0,
+                style: { cursor: "pointer" },
+                onClick: () => onEdit(note),
+                onKeyDown: (e) => {
+                  if (e.key === "Enter" || e.key === " ") {
+                    e.preventDefault();
+                    onEdit(note);
+                  }
+                },
+                children: note.title
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 1, alignItems: "center", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.IconButton,
+              {
+                withTooltip: false,
+                variant: note.isPinned ? "secondary" : "ghost",
+                onClick: () => onTogglePin(note),
+                label: note.isPinned ? t("note.actions.unpin", "Unpin note") : t("note.actions.pin", "Pin note"),
+                children: /* @__PURE__ */ jsxRuntime.jsx(icons.Pin, {})
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.IconButton,
+              {
+                withTooltip: false,
+                variant: "ghost",
+                onClick: () => onEdit(note),
+                label: t("note.actions.edit", "Edit"),
+                children: /* @__PURE__ */ jsxRuntime.jsx(icons.Pencil, {})
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.IconButton,
+              {
+                withTooltip: false,
+                variant: "ghost",
+                onClick: () => onRequestDelete(note),
+                label: t("note.actions.delete", "Delete"),
+                children: /* @__PURE__ */ jsxRuntime.jsx(icons.Trash, {})
+              }
+            )
+          ] })
+        ] }),
+        (authorLabel || timestampLabel) && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral500", ellipsis: true, children: [authorLabel, timestampLabel].filter(Boolean).join(" • ") })
+      ] })
+    }
+  );
+};
+function resolveNormalizedExisting(note) {
+  if (!note) return null;
+  const hasId = Boolean(note.id || note.documentId);
+  return hasId ? normalizeNoteRecord(note) : null;
+}
+function resolveEntityDocumentId(existingDocId, entity) {
+  if (existingDocId) return existingDocId;
+  if (entity.documentId) return entity.documentId;
+  if (entity.id !== null && entity.id !== void 0) return String(entity.id);
+  return "";
+}
+function buildNoteSavePayload(params) {
+  const {
+    trimmedTitle,
+    content,
+    category,
+    isPinned,
+    scopeToLocale,
+    effectiveLocale,
+    normalizedExisting,
+    entity
+  } = params;
+  return {
+    title: trimmedTitle,
+    content: content.trim(),
+    category: normalizeNoteCategory(category),
+    isPinned,
+    entitySlug: normalizedExisting?.entitySlug || entity.slug,
+    entityId: normalizedExisting?.entityId ?? entity.id ?? null,
+    entityDocumentId: resolveEntityDocumentId(
+      normalizedExisting?.entityDocumentId,
+      entity
+    ),
+    entityLocale: scopeToLocale ? effectiveLocale : null
+  };
+}
+const NoteMetadataBox = ({
+  note,
+  uiLocale,
+  t
+}) => /* @__PURE__ */ jsxRuntime.jsx(
+  designSystem.Box,
+  {
+    padding: 4,
+    background: "neutral100",
+    hasRadius: true,
+    "data-testid": "note-modal-meta-box",
+    children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Grid.Root, { gap: 4, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.createdAt", "Created At") }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral800", children: formatNoteTimestamp(note.createdAt, uiLocale) })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.createdBy", "Created By") }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral800", children: formatNoteAuthorDisplay(note.createdBy) })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.updatedAt", "Updated At") }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral800", children: formatNoteTimestamp(note.updatedAt, uiLocale) })
+      ] }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Grid.Item, { col: 6, s: 12, direction: "column", alignItems: "flex-start", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "flex-start", gap: 1, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "sigma", textColor: "neutral600", children: t("note.modal.meta.updatedBy", "Updated By") }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral800", children: formatNoteAuthorDisplay(note.updatedBy) })
+      ] }) })
+    ] })
+  }
+);
+const NoteModal = ({
+  entity,
+  note,
+  isOpen,
+  isSubmitting = false,
+  onClose,
+  onSubmit
+}) => {
+  const { formatMessage, locale: uiLocale } = reactIntl.useIntl();
+  const normalizedExisting = React__namespace.useMemo(
+    () => resolveNormalizedExisting(note),
+    [note]
+  );
+  const isExistingNote = Boolean(normalizedExisting);
+  const [title, setTitle] = React__namespace.useState("");
+  const [content, setContent] = React__namespace.useState("");
+  const [category, setCategory] = React__namespace.useState("general");
+  const [isPinned, setIsPinned] = React__namespace.useState(false);
+  const [scopeToLocale, setScopeToLocale] = React__namespace.useState(false);
+  const [titleError, setTitleError] = React__namespace.useState("");
+  const lastInitKeyRef = React__namespace.useRef(null);
+  const noteIdentityKey = normalizedExisting ? String(normalizedExisting.id || normalizedExisting.documentId) : "new";
+  React__namespace.useEffect(() => {
+    if (!isOpen) {
+      lastInitKeyRef.current = null;
+      return;
+    }
+    if (lastInitKeyRef.current === noteIdentityKey) {
+      return;
+    }
+    lastInitKeyRef.current = noteIdentityKey;
+    setTitle(normalizedExisting?.title ?? "");
+    setContent(normalizedExisting?.content ?? "");
+    setCategory(normalizedExisting?.category ?? "general");
+    setIsPinned(Boolean(normalizedExisting?.isPinned));
+    setScopeToLocale(Boolean(normalizedExisting?.entityLocale));
+    setTitleError("");
+  }, [isOpen, noteIdentityKey, normalizedExisting]);
+  const t = (id, defaultMessage, values) => formatMessage({ id: getTrad(id), defaultMessage }, values);
+  const effectiveLocale = normalizedExisting?.entityLocale || sanitizeEntityLocale(entity.locale) || null;
+  const handleSave = async () => {
+    if (isSubmitting) {
+      return;
+    }
+    const trimmedTitle = title.trim();
+    if (!trimmedTitle) {
+      setTitleError(
+        t("note.modal.validation.titleRequired", "Title is required.")
+      );
+      return;
+    }
+    setTitleError("");
+    const payload = buildNoteSavePayload({
+      trimmedTitle,
+      content,
+      category,
+      isPinned,
+      scopeToLocale,
+      effectiveLocale,
+      normalizedExisting,
+      entity
+    });
+    const targetId = normalizedExisting?.id || normalizedExisting?.documentId;
+    await onSubmit(payload, targetId);
+  };
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    designSystem.Modal.Root,
+    {
+      open: isOpen,
+      onOpenChange: (open) => !open && onClose(),
+      children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Content, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { closeLabel: t("note.modal.actions.close", "Close modal"), children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Title, { children: isExistingNote ? t("note.modal.existing.title", "Edit a note") : t("note.modal.new.title", "Add a note") }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 4, children: [
+          normalizedExisting && /* @__PURE__ */ jsxRuntime.jsx(
+            NoteMetadataBox,
+            {
+              note: normalizedExisting,
+              uiLocale,
+              t
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { name: "title", required: true, error: titleError || void 0, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: t("note.modal.fields.title", "Title") }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.TextInput,
+              {
+                name: "title",
+                value: title,
+                maxLength: MAX_NOTE_TITLE_LENGTH,
+                onChange: (e) => {
+                  setTitle(e.target.value);
+                  if (titleError) setTitleError("");
+                },
+                placeholder: t(
+                  "note.modal.fields.title.placeholder",
+                  "Short summary of this note..."
+                )
+              }
+            ),
+            titleError && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Error, {})
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { name: "category", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: t("note.modal.fields.category", "Category") }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.SingleSelect,
+              {
+                value: category,
+                onChange: (val) => setCategory(normalizeNoteCategory(val)),
+                children: NOTE_CATEGORIES.map((cat) => /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: cat, children: t(
+                  NOTE_CATEGORY_META[cat].labelKey,
+                  NOTE_CATEGORY_META[cat].defaultLabel
+                ) }, cat))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Field.Root, { name: "content", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.Field.Label, { children: t("note.modal.fields.content", "Content") }),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Textarea,
+              {
+                name: "content",
+                value: content,
+                maxLength: MAX_NOTE_CONTENT_LENGTH,
+                onChange: (e) => setContent(e.target.value),
+                placeholder: t(
+                  "note.modal.fields.content.placeholder",
+                  "Write detailed editorial context, review feedback, or follow-up steps..."
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 4, wrap: "wrap", paddingTop: 1, children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Checkbox,
+              {
+                checked: isPinned,
+                onCheckedChange: (checked) => setIsPinned(Boolean(checked)),
+                children: t("note.modal.fields.isPinned", "Pin note to top")
+              }
+            ),
+            effectiveLocale && /* @__PURE__ */ jsxRuntime.jsx(
+              designSystem.Checkbox,
+              {
+                checked: scopeToLocale,
+                onCheckedChange: (checked) => setScopeToLocale(Boolean(checked)),
+                children: t(
+                  "note.modal.fields.scopeToLocale",
+                  "Scope only to locale ({locale})",
+                  {
+                    locale: effectiveLocale
+                  }
+                )
+              }
+            )
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Footer, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Close, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { onClick: onClose, variant: "tertiary", children: t("note.modal.actions.cancel", "Cancel") }) }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.Button,
+            {
+              onClick: handleSave,
+              startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Check, {}),
+              loading: isSubmitting,
+              disabled: isSubmitting,
+              children: t("note.modal.actions.save", "Save")
+            }
+          )
+        ] })
+      ] })
+    }
+  );
+};
+function detectDocumentLocale(props) {
+  const fromDoc = sanitizeEntityLocale(props.document?.locale);
+  if (fromDoc) {
+    return fromDoc;
+  }
+  if (typeof window !== "undefined") {
+    const fromUrl = new URLSearchParams(window.location.search).get(
+      "plugins[i18n][locale]"
+    );
+    return sanitizeEntityLocale(fromUrl);
+  }
+  return null;
+}
+function interpolateTemplateValues(template, values) {
+  if (!values) return template;
+  return Object.entries(values).reduce(
+    (acc, [k, v]) => acc.split(`{${k}}`).join(String(v)),
+    template
+  );
+}
+function formatNoteMessageWithLocale(id, defaultMessage, formatMessage, uiLocale, entityLocale, values) {
+  const fullKey = getTrad(id);
+  const fallbackEntityLoc = entityLocale || (typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("plugins[i18n][locale]") : null);
+  const globalMessages = globalThis.__CM_I18N_MESSAGES__;
+  const override = (uiLocale ? globalMessages?.[uiLocale]?.[fullKey] : void 0) ?? (fallbackEntityLoc ? globalMessages?.[fallbackEntityLoc]?.[fullKey] : void 0);
+  if (override) {
+    return interpolateTemplateValues(override, values);
+  }
+  return formatMessage({ id: fullKey, defaultMessage }, values);
+}
+const NotesSidePanelContent = ({
+  entity
+}) => {
+  const { formatMessage, locale: uiLocale } = reactIntl.useIntl();
+  const [searchQuery, setSearchQuery] = React__namespace.useState("");
+  const [categoryFilter, setCategoryFilter] = React__namespace.useState("all");
+  const [isModalOpen, setIsModalOpen] = React__namespace.useState(false);
+  const [activeNote, setActiveNote] = React__namespace.useState(null);
+  const [noteToDelete, setNoteToDelete] = React__namespace.useState(
+    null
+  );
+  const { notes, isLoading, isMutating, createNote, updateNote, deleteNote } = useNotes({
+    entitySlug: entity.slug,
+    entityDocumentId: entity.documentId,
+    entityId: entity.id,
+    entityLocale: entity.locale
+  });
+  const t = (id, defaultMessage, values) => formatNoteMessageWithLocale(
+    id,
+    defaultMessage,
+    formatMessage,
+    uiLocale,
+    entity.locale,
+    values
+  );
+  const visibleNotes = React__namespace.useMemo(
+    () => filterNotesList(notes, {
+      category: categoryFilter,
+      search: searchQuery,
+      sort: "DESC"
+    }),
+    [notes, categoryFilter, searchQuery]
+  );
+  const showFilterControls = notes.length > 1 || Boolean(searchQuery.trim()) || categoryFilter !== "all";
+  const handleUpsert = async (payload, existingId) => {
+    const saved = existingId !== void 0 && existingId !== "" ? await updateNote(existingId, payload) : await createNote(payload);
+    if (saved) {
+      setIsModalOpen(false);
+      setActiveNote(null);
+    }
+  };
+  const handleTogglePin = async (note) => {
+    const targetId = note.id || note.documentId;
+    if (!targetId) return;
+    await updateNote(targetId, { isPinned: !note.isPinned });
+  };
+  const handleConfirmDelete = async (note) => {
+    const targetId = note.id || note.documentId;
+    if (!targetId) return;
+    const deleted = await deleteNote(targetId);
+    if (deleted) {
+      setNoteToDelete(null);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, paddingBottom: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 3, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { justifyContent: "space-between", alignItems: "center", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral600", children: t("notes.sidePanel.count", "{count} note(s)", {
+        count: notes.length
+      }) }),
+      entity.locale && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "neutral150", textColor: "neutral800", children: entity.locale.toUpperCase() })
+    ] }),
+    showFilterControls && /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", alignItems: "stretch", gap: 2, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        designSystem.TextInput,
+        {
+          name: "noteSearch",
+          size: "S",
+          value: searchQuery,
+          onChange: (e) => setSearchQuery(e.target.value),
+          placeholder: t(
+            "notes.sidePanel.search.placeholder",
+            "Filter notes..."
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        designSystem.SingleSelect,
+        {
+          size: "S",
+          value: categoryFilter,
+          onChange: (val) => setCategoryFilter(
+            String(val) || "all"
+          ),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: "all", children: t("category.all", "All categories") }),
+            NOTE_CATEGORIES.map((cat) => /* @__PURE__ */ jsxRuntime.jsx(designSystem.SingleSelectOption, { value: cat, children: t(
+              NOTE_CATEGORY_META[cat].labelKey,
+              NOTE_CATEGORY_META[cat].defaultLabel
+            ) }, cat))
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Divider, {}),
+    isLoading ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { justifyContent: "center", paddingTop: 3, paddingBottom: 3, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Loader, { small: true, children: t("notes.loading", "Loading Content ...") }) }) : visibleNotes.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 3, background: "neutral100", hasRadius: true, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral600", children: notes.length === 0 ? t(
+      "notes.sidePanel.empty",
+      "No editorial notes attached to this entry yet."
+    ) : t(
+      "notes.sidePanel.noMatches",
+      "No notes match the current filter."
+    ) }) }) : /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Flex,
+      {
+        direction: "column",
+        alignItems: "stretch",
+        gap: 2,
+        style: {
+          maxHeight: "240px",
+          overflowY: "auto",
+          overflowX: "hidden"
+        },
+        children: visibleNotes.map((item) => /* @__PURE__ */ jsxRuntime.jsx(
+          NoteListItem,
+          {
+            note: item,
+            onEdit: (selected) => {
+              setActiveNote(selected);
+              setIsModalOpen(true);
+            },
+            onRequestDelete: (selected) => setNoteToDelete(selected),
+            onTogglePin: handleTogglePin
+          },
+          String(item.id || item.documentId)
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Button,
+      {
+        fullWidth: true,
+        variant: "secondary",
+        startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Plus, {}),
+        disabled: isLoading || isMutating,
+        onClick: () => {
+          setActiveNote(null);
+          setIsModalOpen(true);
+        },
+        children: t("note.modal.new.title", "Add a note")
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      NoteModal,
+      {
+        entity,
+        note: activeNote,
+        isOpen: isModalOpen,
+        isSubmitting: isMutating,
+        onClose: () => {
+          setIsModalOpen(false);
+          setActiveNote(null);
+        },
+        onSubmit: handleUpsert
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      DeleteNoteDialog,
+      {
+        note: noteToDelete,
+        isSubmitting: isMutating,
+        onCancel: () => setNoteToDelete(null),
+        onConfirm: handleConfirmDelete
+      }
+    )
+  ] }) });
+};
+function resolveSidePanelDocumentId(props) {
+  if (props.documentId) return props.documentId;
+  const docId = props.document?.documentId;
+  return typeof docId === "string" ? docId : "";
+}
+function resolveSidePanelNumericId(props) {
+  const id = props.document?.id;
+  if (typeof id === "number" || typeof id === "string") {
+    return id;
+  }
+  return null;
+}
+function resolveSidePanelEntity(props) {
+  const slug = props.model ?? "";
+  const documentId = resolveSidePanelDocumentId(props);
+  const numericId = resolveSidePanelNumericId(props);
+  const isSingleType = props.collectionType === "single-types" || props.collectionType === "singleType";
+  const hasIdentifier = Boolean(
+    documentId || numericId !== null || isSingleType
+  );
+  if (!slug || !hasIdentifier) {
+    return null;
+  }
+  return {
+    id: numericId,
+    documentId: documentId || (numericId !== null ? String(numericId) : "single"),
+    slug,
+    locale: detectDocumentLocale(props)
+  };
+}
+const NotesSidePanel = (props) => {
+  const { formatMessage, locale: uiLocale } = reactIntl.useIntl();
+  const entity = resolveSidePanelEntity(props);
+  if (!entity) {
+    return null;
+  }
+  return {
+    title: formatNoteMessageWithLocale(
+      "plugin.name",
+      "Notes",
+      formatMessage,
+      uiLocale,
+      entity.locale
+    ),
+    content: /* @__PURE__ */ jsxRuntime.jsx(NotesSidePanelContent, { entity })
+  };
+};
+const PluginIcon = () => /* @__PURE__ */ jsxRuntime.jsx(icons.File, {});
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.plugin.name`,
+        defaultMessage: "Notes"
+      },
+      Component: () => Promise.resolve().then(() => require("./NotesHomePage-C5eNNxl9.cjs")).then((mod) => ({
+        default: mod.NotesHomePage
+      })),
+      permissions: [
+        {
+          action: `plugin::${PLUGIN_ID}.read`,
+          subject: null
+        }
+      ]
+    });
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  bootstrap(app) {
+    const cmPlugin = app.getPlugin("content-manager");
+    if (cmPlugin?.apis && typeof cmPlugin.apis.addEditViewSidePanel === "function") {
+      cmPlugin.apis.addEditViewSidePanel([NotesSidePanel]);
+    }
+  },
+  registerTrads: createRegisterTrads({
+    pluginId: PLUGIN_ID,
+    defaultLocales: [
+      "en",
+      "es",
+      "ar",
+      "tr",
+      "fr",
+      "de",
+      "it",
+      "pt",
+      "ru",
+      "zh"
+    ],
+    loadTranslation: (locale) => __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/ar.json": () => Promise.resolve().then(() => require("./ar-NJ-XJhAU.cjs")), "./translations/de.json": () => Promise.resolve().then(() => require("./de-d-M42GQs.cjs")), "./translations/en.json": () => Promise.resolve().then(() => require("./en-C8MGI5Fp.cjs")), "./translations/es.json": () => Promise.resolve().then(() => require("./es-BZY_kUPd.cjs")), "./translations/fr.json": () => Promise.resolve().then(() => require("./fr-D6Ism7Y3.cjs")), "./translations/it.json": () => Promise.resolve().then(() => require("./it-DyBVYzjD.cjs")), "./translations/pt.json": () => Promise.resolve().then(() => require("./pt-BOHJueLP.cjs")), "./translations/ru.json": () => Promise.resolve().then(() => require("./ru-DhigZM8k.cjs")), "./translations/tr.json": () => Promise.resolve().then(() => require("./tr-CNFZeutu.cjs")), "./translations/zh.json": () => Promise.resolve().then(() => require("./zh-BriU4KiK.cjs")) }), `./translations/${locale}.json`, 3)
+  })
+};
+exports.DeleteNoteDialog = DeleteNoteDialog;
+exports.NOTE_CATEGORIES = NOTE_CATEGORIES;
+exports.NOTE_CATEGORY_META = NOTE_CATEGORY_META;
+exports.NoteModal = NoteModal;
+exports.buildContentManagerNoteLink = buildContentManagerNoteLink;
+exports.filterNotesList = filterNotesList;
+exports.formatNoteAuthorDisplay = formatNoteAuthorDisplay;
+exports.formatNoteTimestamp = formatNoteTimestamp;
+exports.getTrad = getTrad;
+exports.index = index;
+exports.useNotes = useNotes;