intlayer-editor 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Sébastien Vanvelthem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,175 @@
+# Intlayer: Next-Level Content Management in JavaScript
+
+**Intlayer** is an innovative Content Management System (CMS) designed specifically for JavaScript developers. It enables seamless transpilation of JavaScript content into structured dictionaries, making integration into your codebase straightforward and efficient.
+
+## Why Choose Intlayer?
+
+- **JavaScript-Powered Content Management**: Harness the flexibility of JavaScript to define and manage your content efficiently.
+- **Type-Safe Environment**: Leverage TypeScript to ensure all your content definitions are precise and error-free.
+- **Integrated Content Files**: Keep your translations close to their respective components, enhancing maintainability and clarity.
+
+## intlayer package
+
+`intlayer` package intend to declare your content in a structured way, using JavaScript.
+
+To build dictionaries from this declaration, you can use [intlayer-cli](https://github.com/aypineau/intlayer/blob/main/packages/intlayer-cli/readme.md).
+And to interpret intlayer dictionaries you can interpreters, such as [react-intlayer](https://github.com/aypineau/intlayer/blob/main/packages/react-intlayer/readme.md), or [next-intlayer](https://github.com/aypineau/intlayer/blob/main/packages/next-intlayer/readme.md)
+
+## Getting Started with Intlayer
+
+[See how to use intlayer with NextJS](https://github.com/aypineau/intlayer/blob/main/readme.md)
+
+### Install Package
+
+Install the necessary packages using npm:
+
+```bash
+npm install intlayer
+```
+
+```bash
+yarn install intlayer
+```
+
+```bash
+pnpm install intlayer
+```
+
+### Manage Your Content
+
+Create and manage your content dictionaries:
+
+#### Using typescript
+
+```typescript
+// src/app/[locale]/page.content.ts
+import { t, enu, type ContentModule } from "intlayer";
+
+const pageContent: ContentModule = {
+  id: "page",
+  getStarted: {
+    main: t({
+      en: "Get started by editing",
+      fr: "Commencez par éditer",
+      es: "Comience por editar",
+    }),
+    pageLink: "src/app/page.tsx",
+  },
+  nestedContent: {
+    id: "enumeration",
+    numberOfCar: enu({
+      "<-1": "Less than minus one car",
+      "-1": "Minus one car",
+      "0": "No cars",
+      "1": "One car",
+      ">5": "Some cars",
+      ">19": "Many cars",
+    }),
+  },
+};
+
+// Content should be exported as default
+export default pageContent;
+```
+
+#### Using ECMAScript modules
+
+```javascript
+// src/app/[locale]/page.content.mjs
+
+import { t } from "intlayer";
+
+/** @type {import('intlayer').ContentModule} */
+const pageContent = {
+  id: "page",
+  getStarted: {
+    main: t({
+      en: "Get started by editing",
+      fr: "Commencez par éditer",
+      es: "Comience por editar",
+    }),
+    pageLink: "src/app/page.tsx",
+  },
+  nestedContent: {
+    id: "enumeration",
+    numberOfCar: enu({
+      "<-1": "Less than minus one car",
+      "-1": "Minus one car",
+      "0": "No cars",
+      "1": "One car",
+      ">5": "Some cars",
+      ">19": "Many cars",
+    }),
+  },
+};
+
+// Content should be exported as default
+export default pageContent;
+```
+
+#### Using CommonJS modules
+
+```javascript
+// src/app/[locale]/page.content.cjs
+
+const { t } = require("intlayer");
+
+/** @type {import('intlayer').ContentModule} */
+const pageContent = {
+  id: "page",
+  getStarted: {
+    main: t({
+      en: "Get started by editing",
+      fr: "Commencez par éditer",
+      es: "Comience por editar",
+    }),
+    pageLink: "src/app/page.tsx",
+  },
+  nestedContent: {
+    id: "enumeration",
+    numberOfCar: enu({
+      "<-1": "Less than minus one car",
+      "-1": "Minus one car",
+      "0": "No cars",
+      "1": "One car",
+      ">5": "Some cars",
+      ">19": "Many cars",
+    }),
+  },
+};
+
+// Content should be exported as default
+module.exports = pageContent;
+```
+
+#### Using JSON
+
+```json5
+// src/app/[locale]/page.content.json
+{
+  "id": "page",
+  "getStarted": {
+    "main": {
+      "nodeType": "translation",
+      "en": "Get started by editing",
+      "fr": "Commencez par éditer",
+      "es": "Comience por editar",
+    },
+    "pageLink": "src/app/page.tsx",
+  },
+  "nestedContent": {
+    "id": "enumeration",
+    "nodeType": "enumeration",
+    "numberOfCar": {
+      "<-1": "Less than minus one car",
+      "-1": "Minus one car",
+      "0": "No cars",
+      "1": "One car",
+      ">5": "Some cars",
+      ">19": "Many cars",
+    },
+  },
+}
+```
+
+This version emphasizes ease of use, practical steps, and the professional application of Intlayer in a Next.js environment.

package/bin/start-server.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { startIntlayerEditor } = require('../dist/cjs/server/index.cjs');
+const pkg = require('../package.json');
+
+program
+  .version(pkg.version)
+  .description('Command-line interface to start the Intlayer Editor server');
+
+program
+  .command('start')
+  .description('Start the Intlayer editor server')
+  .action(() => startIntlayerEditor());
+
+program.parse(process.argv);

package/dist/cjs/client/ContentEditionLayout.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ContentEditionLayout_exports = {};
+__export(ContentEditionLayout_exports, {
+  ContentEditionLayout: () => ContentEditionLayout
+});
+module.exports = __toCommonJS(ContentEditionLayout_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_EditionPanel = require('./EditionPanel/index.cjs');
+const ContentEditionLayout = ({
+  children,
+  locale,
+  setLocale,
+  localeList
+}) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+  children,
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_EditionPanel.EditionPanel,
+    {
+      locale,
+      localeList,
+      setLocale
+    }
+  )
+] });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentEditionLayout
+});
+//# sourceMappingURL=ContentEditionLayout.cjs.map

package/dist/cjs/client/ContentEditionLayout.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/ContentEditionLayout.tsx"],"sourcesContent":["import type { Locales } from '@intlayer/config/client';\nimport type { FC, ReactNode } from 'react';\nimport { EditionPanel } from './EditionPanel/index';\n\nexport type ContentEditionLayoutProps = {\n  children?: ReactNode;\n  locale: Locales;\n  localeList: Locales[];\n  setLocale: (locale: Locales) => void;\n};\n\nexport const ContentEditionLayout: FC<ContentEditionLayoutProps> = ({\n  children,\n  locale,\n  setLocale,\n  localeList,\n}) => (\n  <>\n    {children}\n    <EditionPanel\n      locale={locale}\n      localeList={localeList}\n      setLocale={setLocale}\n    />\n  </>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBE;AAfF,0BAA6B;AAStB,MAAM,uBAAsD,CAAC;AAAA,EAClE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MACE,4EACG;AAAA;AAAA,EACD;AAAA,IAAC;AAAA;AAAA,MACC;AAAA,MACA;AAAA,MACA;AAAA;AAAA,EACF;AAAA,GACF;","names":[]}

package/dist/cjs/client/ContentEditionLayout.d.ts

@@ -0,0 +1,12 @@
+import { Locales } from '@intlayer/config/client';
+import { ReactNode, FC } from 'react';
+
+type ContentEditionLayoutProps = {
+    children?: ReactNode;
+    locale: Locales;
+    localeList: Locales[];
+    setLocale: (locale: Locales) => void;
+};
+declare const ContentEditionLayout: FC<ContentEditionLayoutProps>;
+
+export { ContentEditionLayout, type ContentEditionLayoutProps };

package/dist/cjs/client/ContentSelectorWrapper.cjs

@@ -0,0 +1,49 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ContentSelectorWrapper_exports = {};
+__export(ContentSelectorWrapper_exports, {
+  ContentSelectorWrapper: () => ContentSelectorWrapper
+});
+module.exports = __toCommonJS(ContentSelectorWrapper_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_design_system = require("@intlayer/design-system");
+var import_useEditedContentStore = require('./EditionPanel/useEditedContentStore.cjs');
+var import_useEditionPanelStore = require('./EditionPanel/useEditionPanelStore.cjs');
+const ContentSelectorWrapper = ({
+  children,
+  dictionaryId,
+  dictionaryPath,
+  keyPath
+}) => {
+  const { setFocusedContent } = (0, import_useEditionPanelStore.useEditionPanelStore)();
+  const handleSelect = () => setFocusedContent({
+    dictionaryId,
+    dictionaryPath,
+    keyPath
+  });
+  const { getEditedContentValue } = (0, import_useEditedContentStore.useEditedContentStore)();
+  const editedValue = getEditedContentValue(dictionaryPath, keyPath);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_design_system.ContentSelector, { onSelect: handleSelect, children: editedValue ?? children });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentSelectorWrapper
+});
+//# sourceMappingURL=ContentSelectorWrapper.cjs.map

package/dist/cjs/client/ContentSelectorWrapper.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/ContentSelectorWrapper.tsx"],"sourcesContent":["'use client';\n\nimport type { KeyPath } from '@intlayer/core';\nimport { ContentSelector } from '@intlayer/design-system';\nimport type { FC } from 'react';\nimport { useEditedContentStore } from './EditionPanel/useEditedContentStore';\nimport { useEditionPanelStore } from './EditionPanel/useEditionPanelStore';\n\ntype ContentSelectorWrapperProps = {\n  children: string;\n  dictionaryId: string;\n  dictionaryPath: string;\n  keyPath: KeyPath[];\n};\n\nexport const ContentSelectorWrapper: FC<ContentSelectorWrapperProps> = ({\n  children,\n  dictionaryId,\n  dictionaryPath,\n  keyPath,\n}) => {\n  const { setFocusedContent } = useEditionPanelStore();\n  const handleSelect = () =>\n    setFocusedContent({\n      dictionaryId,\n      dictionaryPath,\n      keyPath,\n    });\n\n  const { getEditedContentValue } = useEditedContentStore();\n  const editedValue = getEditedContentValue(dictionaryPath, keyPath);\n\n  return (\n    <ContentSelector onSelect={handleSelect}>\n      {editedValue ?? children}\n    </ContentSelector>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCI;AA9BJ,2BAAgC;AAEhC,mCAAsC;AACtC,kCAAqC;AAS9B,MAAM,yBAA0D,CAAC;AAAA,EACtE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,EAAE,kBAAkB,QAAI,kDAAqB;AACnD,QAAM,eAAe,MACnB,kBAAkB;AAAA,IAChB;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAEH,QAAM,EAAE,sBAAsB,QAAI,oDAAsB;AACxD,QAAM,cAAc,sBAAsB,gBAAgB,OAAO;AAEjE,SACE,4CAAC,wCAAgB,UAAU,cACxB,yBAAe,UAClB;AAEJ;","names":[]}

package/dist/cjs/client/ContentSelectorWrapper.d.ts

@@ -0,0 +1,12 @@
+import { KeyPath } from '@intlayer/core';
+import { FC } from 'react';
+
+type ContentSelectorWrapperProps = {
+    children: string;
+    dictionaryId: string;
+    dictionaryPath: string;
+    keyPath: KeyPath[];
+};
+declare const ContentSelectorWrapper: FC<ContentSelectorWrapperProps>;
+
+export { ContentSelectorWrapper };

package/dist/cjs/client/EditionPanel/EditionPanel.cjs

@@ -0,0 +1,101 @@
+"use strict";
+"use client";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EditionPanel_exports = {};
+__export(EditionPanel_exports, {
+  EditionPanel: () => EditionPanel
+});
+module.exports = __toCommonJS(EditionPanel_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_design_system = require("@intlayer/design-system");
+var import_dictionaries_entry = __toESM(require("@intlayer/dictionaries-entry"));
+var import_react = require("react");
+var import_useEditorServer = require('../useEditorServer.cjs');
+var import_useEditedContentStore = require('./useEditedContentStore.cjs');
+var import_useEditionPanelStore = require('./useEditionPanelStore.cjs');
+const EditionPanel = ({
+  locale,
+  localeList,
+  setLocale
+}) => {
+  const { open } = (0, import_design_system.useRightDrawerStore)();
+  const { focusedContent, setFocusedContent } = (0, import_useEditionPanelStore.useEditionPanelStore)();
+  const { editedContent, addEditedContent, clearEditedDictionaryContent } = (0, import_useEditedContentStore.useEditedContentStore)();
+  const { editContentRequest } = (0, import_useEditorServer.useEditorServer)();
+  (0, import_react.useEffect)(() => {
+    if (focusedContent !== null) {
+      open();
+    }
+  }, [focusedContent, open]);
+  if (!focusedContent) {
+    return null;
+  }
+  const dictionary = import_dictionaries_entry.default[focusedContent.dictionaryId];
+  if (!dictionary?.filePath) {
+    return null;
+  }
+  const dictionaryPath = dictionary.filePath;
+  const editedDictionaryContent = editedContent[dictionaryPath] ?? [];
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_design_system.RightDrawer,
+    {
+      title: dictionary.id,
+      label: `Edit dictionary ${dictionary.id}`,
+      header: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_design_system.LocaleSwitcher,
+        {
+          setLocale,
+          locale,
+          localeList
+        }
+      ),
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_design_system.DictionaryEditor,
+        {
+          dictionary,
+          locale,
+          focusedKeyPath: focusedContent.keyPath,
+          editedContent: editedDictionaryContent,
+          onFocusKeyPath: (keyPath) => setFocusedContent({ ...focusedContent, keyPath }),
+          onContentChange: (keyPath, newValue) => addEditedContent(dictionaryPath, keyPath, newValue),
+          onValidEdition: editContentRequest,
+          onCancelEdition: () => {
+            clearEditedDictionaryContent(dictionaryPath);
+            setFocusedContent(null);
+          }
+        }
+      )
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EditionPanel
+});
+//# sourceMappingURL=EditionPanel.cjs.map

package/dist/cjs/client/EditionPanel/EditionPanel.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/EditionPanel/EditionPanel.tsx"],"sourcesContent":["'use client';\n\nimport type { Locales } from '@intlayer/config/client';\nimport type { ContentModule } from '@intlayer/core';\nimport {\n  useRightDrawerStore,\n  RightDrawer,\n  DictionaryEditor,\n  LocaleSwitcher,\n} from '@intlayer/design-system';\n/**\n * @intlayer/dictionaries-entry is a package that only returns the dictionary entry path.\n * Using an external package allow to alias it in the bundle configuration (such as webpack).\n * The alias allow hot reload the app (such as nextjs) on any dictionary change.\n */\nimport dictionaries from '@intlayer/dictionaries-entry';\nimport { type FC, useEffect } from 'react';\nimport { useEditorServer } from '../useEditorServer';\nimport { useEditedContentStore } from './useEditedContentStore';\nimport { useEditionPanelStore } from './useEditionPanelStore';\n\ntype EditionPanelProps = {\n  locale: Locales;\n  localeList: Locales[];\n  setLocale: (locale: Locales) => void;\n};\n\nexport const EditionPanel: FC<EditionPanelProps> = ({\n  locale,\n  localeList,\n  setLocale,\n}) => {\n  const { open } = useRightDrawerStore();\n  const { focusedContent, setFocusedContent } = useEditionPanelStore();\n  const { editedContent, addEditedContent, clearEditedDictionaryContent } =\n    useEditedContentStore();\n  const { editContentRequest } = useEditorServer();\n\n  // Use effect to react to changes in focusedContent\n  useEffect(() => {\n    if (focusedContent !== null) {\n      open(); // Call the open function from useRightDrawerStore\n    }\n  }, [focusedContent, open]); // Depend on focusedContent and open to trigger the effect\n\n  if (!focusedContent) {\n    return null;\n  }\n\n  const dictionary: ContentModule = dictionaries[focusedContent.dictionaryId];\n\n  if (!dictionary?.filePath) {\n    return null;\n  }\n\n  const dictionaryPath = dictionary.filePath;\n  const editedDictionaryContent = editedContent[dictionaryPath] ?? [];\n\n  return (\n    <RightDrawer\n      title={dictionary.id}\n      label={`Edit dictionary ${dictionary.id}`}\n      header={\n        <LocaleSwitcher\n          setLocale={setLocale}\n          locale={locale}\n          localeList={localeList}\n        />\n      }\n    >\n      <DictionaryEditor\n        dictionary={dictionary}\n        locale={locale}\n        focusedKeyPath={focusedContent.keyPath}\n        editedContent={editedDictionaryContent}\n        onFocusKeyPath={(keyPath) =>\n          setFocusedContent({ ...focusedContent, keyPath })\n        }\n        onContentChange={(keyPath, newValue) =>\n          addEditedContent(dictionaryPath, keyPath, newValue)\n        }\n        onValidEdition={editContentRequest}\n        onCancelEdition={() => {\n          clearEditedDictionaryContent(dictionaryPath);\n          setFocusedContent(null);\n        }}\n      />\n    </RightDrawer>\n  );\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA+DQ;AA3DR,2BAKO;AAMP,gCAAyB;AACzB,mBAAmC;AACnC,6BAAgC;AAChC,mCAAsC;AACtC,kCAAqC;AAQ9B,MAAM,eAAsC,CAAC;AAAA,EAClD;AAAA,EACA;AAAA,EACA;AACF,MAAM;AACJ,QAAM,EAAE,KAAK,QAAI,0CAAoB;AACrC,QAAM,EAAE,gBAAgB,kBAAkB,QAAI,kDAAqB;AACnE,QAAM,EAAE,eAAe,kBAAkB,6BAA6B,QACpE,oDAAsB;AACxB,QAAM,EAAE,mBAAmB,QAAI,wCAAgB;AAG/C,8BAAU,MAAM;AACd,QAAI,mBAAmB,MAAM;AAC3B,WAAK;AAAA,IACP;AAAA,EACF,GAAG,CAAC,gBAAgB,IAAI,CAAC;AAEzB,MAAI,CAAC,gBAAgB;AACnB,WAAO;AAAA,EACT;AAEA,QAAM,aAA4B,0BAAAA,QAAa,eAAe,YAAY;AAE1E,MAAI,CAAC,YAAY,UAAU;AACzB,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,WAAW;AAClC,QAAM,0BAA0B,cAAc,cAAc,KAAK,CAAC;AAElE,SACE;AAAA,IAAC;AAAA;AAAA,MACC,OAAO,WAAW;AAAA,MAClB,OAAO,mBAAmB,WAAW,EAAE;AAAA,MACvC,QACE;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA;AAAA;AAAA,MACF;AAAA,MAGF;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA;AAAA,UACA,gBAAgB,eAAe;AAAA,UAC/B,eAAe;AAAA,UACf,gBAAgB,CAAC,YACf,kBAAkB,EAAE,GAAG,gBAAgB,QAAQ,CAAC;AAAA,UAElD,iBAAiB,CAAC,SAAS,aACzB,iBAAiB,gBAAgB,SAAS,QAAQ;AAAA,UAEpD,gBAAgB;AAAA,UAChB,iBAAiB,MAAM;AACrB,yCAA6B,cAAc;AAC3C,8BAAkB,IAAI;AAAA,UACxB;AAAA;AAAA,MACF;AAAA;AAAA,EACF;AAEJ;","names":["dictionaries"]}

package/dist/cjs/client/EditionPanel/EditionPanel.d.ts

@@ -0,0 +1,11 @@
+import { Locales } from '@intlayer/config/client';
+import { FC } from 'react';
+
+type EditionPanelProps = {
+    locale: Locales;
+    localeList: Locales[];
+    setLocale: (locale: Locales) => void;
+};
+declare const EditionPanel: FC<EditionPanelProps>;
+
+export { EditionPanel };

package/dist/cjs/client/EditionPanel/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EditionPanel_exports = {};
+module.exports = __toCommonJS(EditionPanel_exports);
+__reExport(EditionPanel_exports, require('./EditionPanel.cjs'), module.exports);
+__reExport(EditionPanel_exports, require('./useEditionPanelStore.cjs'), module.exports);
+__reExport(EditionPanel_exports, require('./useEditedContentStore.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./EditionPanel.cjs'),
+  ...require('./useEditionPanelStore.cjs'),
+  ...require('./useEditedContentStore.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/client/EditionPanel/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/EditionPanel/index.ts"],"sourcesContent":["export * from './EditionPanel';\nexport * from './useEditionPanelStore';\nexport * from './useEditedContentStore';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,iCAAc,2BAAd;AACA,iCAAc,mCADd;AAEA,iCAAc,oCAFd;","names":[]}

package/dist/cjs/client/EditionPanel/index.d.ts

@@ -0,0 +1,9 @@
+export { EditionPanel } from './EditionPanel.js';
+export { useEditionPanelStore } from './useEditionPanelStore.js';
+export { EditedContent, useEditedContentStore } from './useEditedContentStore.js';
+import '@intlayer/config/client';
+import 'react';
+import 'zustand';
+import '@intlayer/core';
+import 'zustand/middleware';
+import '@intlayer/design-system';

package/dist/cjs/client/EditionPanel/useEditedContentStore.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useEditedContentStore_exports = {};
+__export(useEditedContentStore_exports, {
+  useEditedContentStore: () => useEditedContentStore
+});
+module.exports = __toCommonJS(useEditedContentStore_exports);
+var import_zustand = require("zustand");
+var import_middleware = require("zustand/middleware");
+const isSameKeyPath = (keyPath1, keyPath2) => keyPath1.every(
+  (element, index) => keyPath2[index] && keyPath2[index].key === element.key && keyPath2[index].type === element.type
+);
+const useEditedContentStore = (0, import_zustand.create)(
+  (0, import_middleware.persist)(
+    (set, get) => ({
+      editedContent: {},
+      addEditedContent: (dictionaryPath, keyPath, newValue) => {
+        set((state) => {
+          const editedContent = state.editedContent[dictionaryPath] ?? [];
+          return {
+            editedContent: {
+              ...state.editedContent,
+              [dictionaryPath]: [
+                ...editedContent.filter(
+                  (content) => !isSameKeyPath(content.keyPath, keyPath)
+                ),
+                {
+                  keyPath,
+                  newValue
+                }
+              ]
+            }
+          };
+        });
+      },
+      removeEditedContent: (dictionaryPath, keyPath) => {
+        set((state) => {
+          const editedContent = state.editedContent[dictionaryPath] ?? [];
+          return {
+            editedContent: {
+              ...state.editedContent,
+              [dictionaryPath]: editedContent.filter(
+                (content) => content.keyPath !== keyPath
+              )
+            }
+          };
+        });
+      },
+      clearEditedDictionaryContent: (dictionaryPath) => {
+        set((state) => ({
+          editedContent: {
+            ...state.editedContent,
+            [dictionaryPath]: []
+          }
+        }));
+      },
+      clearEditedContent: () => {
+        set({ editedContent: {} });
+      },
+      getEditedContentValue: (dictionaryPath, keyPath) => get().editedContent[dictionaryPath]?.find(
+        (content) => isSameKeyPath(content.keyPath, keyPath)
+      )?.newValue
+    }),
+    {
+      name: "edited-content-store",
+      storage: (0, import_middleware.createJSONStorage)(() => sessionStorage)
+    }
+  )
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEditedContentStore
+});
+//# sourceMappingURL=useEditedContentStore.cjs.map

package/dist/cjs/client/EditionPanel/useEditedContentStore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/client/EditionPanel/useEditedContentStore.ts"],"sourcesContent":["import type { KeyPath } from '@intlayer/core';\nimport type { FileContent } from '@intlayer/design-system';\nimport { create } from 'zustand';\nimport { persist, createJSONStorage } from 'zustand/middleware';\n\ntype DictionaryPath = string;\n\nexport type EditedContent = Record<DictionaryPath, FileContent[]>;\n\ntype EditedContentStore = {\n  editedContent: EditedContent;\n  addEditedContent: (\n    dictionaryPath: DictionaryPath,\n    keyPath: KeyPath[],\n    newValue: string\n  ) => void;\n  removeEditedContent: (\n    dictionaryPath: DictionaryPath,\n    keyPath: KeyPath[]\n  ) => void;\n  clearEditedDictionaryContent: (dictionaryPath: DictionaryPath) => void;\n  clearEditedContent: () => void;\n  getEditedContentValue: (\n    dictionaryPath: DictionaryPath,\n    keyPath: KeyPath[]\n  ) => string | undefined;\n};\n\nconst isSameKeyPath = (keyPath1: KeyPath[], keyPath2: KeyPath[]) =>\n  keyPath1.every(\n    (element, index) =>\n      keyPath2[index] &&\n      keyPath2[index].key === element.key &&\n      keyPath2[index].type === element.type\n  );\n\nexport const useEditedContentStore = create(\n  persist<EditedContentStore>(\n    (set, get) => ({\n      editedContent: {},\n      addEditedContent: (dictionaryPath, keyPath, newValue) => {\n        set((state) => {\n          const editedContent = state.editedContent[dictionaryPath] ?? [];\n          return {\n            editedContent: {\n              ...state.editedContent,\n              [dictionaryPath]: [\n                ...editedContent.filter(\n                  (content) => !isSameKeyPath(content.keyPath, keyPath)\n                ),\n                {\n                  keyPath,\n                  newValue,\n                },\n              ],\n            },\n          };\n        });\n      },\n\n      removeEditedContent: (dictionaryPath, keyPath) => {\n        set((state) => {\n          const editedContent = state.editedContent[dictionaryPath] ?? [];\n          return {\n            editedContent: {\n              ...state.editedContent,\n              [dictionaryPath]: editedContent.filter(\n                (content) => content.keyPath !== keyPath\n              ),\n            },\n          };\n        });\n      },\n\n      clearEditedDictionaryContent: (dictionaryPath) => {\n        set((state) => ({\n          editedContent: {\n            ...state.editedContent,\n            [dictionaryPath]: [],\n          },\n        }));\n      },\n\n      clearEditedContent: () => {\n        set({ editedContent: {} });\n      },\n\n      getEditedContentValue: (dictionaryPath, keyPath): string | undefined =>\n        get().editedContent[dictionaryPath]?.find((content) =>\n          isSameKeyPath(content.keyPath, keyPath)\n        )?.newValue,\n    }),\n    {\n      name: 'edited-content-store',\n      storage: createJSONStorage(() => sessionStorage),\n    }\n  )\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,qBAAuB;AACvB,wBAA2C;AAyB3C,MAAM,gBAAgB,CAAC,UAAqB,aAC1C,SAAS;AAAA,EACP,CAAC,SAAS,UACR,SAAS,KAAK,KACd,SAAS,KAAK,EAAE,QAAQ,QAAQ,OAChC,SAAS,KAAK,EAAE,SAAS,QAAQ;AACrC;AAEK,MAAM,4BAAwB;AAAA,MACnC;AAAA,IACE,CAAC,KAAK,SAAS;AAAA,MACb,eAAe,CAAC;AAAA,MAChB,kBAAkB,CAAC,gBAAgB,SAAS,aAAa;AACvD,YAAI,CAAC,UAAU;AACb,gBAAM,gBAAgB,MAAM,cAAc,cAAc,KAAK,CAAC;AAC9D,iBAAO;AAAA,YACL,eAAe;AAAA,cACb,GAAG,MAAM;AAAA,cACT,CAAC,cAAc,GAAG;AAAA,gBAChB,GAAG,cAAc;AAAA,kBACf,CAAC,YAAY,CAAC,cAAc,QAAQ,SAAS,OAAO;AAAA,gBACtD;AAAA,gBACA;AAAA,kBACE;AAAA,kBACA;AAAA,gBACF;AAAA,cACF;AAAA,YACF;AAAA,UACF;AAAA,QACF,CAAC;AAAA,MACH;AAAA,MAEA,qBAAqB,CAAC,gBAAgB,YAAY;AAChD,YAAI,CAAC,UAAU;AACb,gBAAM,gBAAgB,MAAM,cAAc,cAAc,KAAK,CAAC;AAC9D,iBAAO;AAAA,YACL,eAAe;AAAA,cACb,GAAG,MAAM;AAAA,cACT,CAAC,cAAc,GAAG,cAAc;AAAA,gBAC9B,CAAC,YAAY,QAAQ,YAAY;AAAA,cACnC;AAAA,YACF;AAAA,UACF;AAAA,QACF,CAAC;AAAA,MACH;AAAA,MAEA,8BAA8B,CAAC,mBAAmB;AAChD,YAAI,CAAC,WAAW;AAAA,UACd,eAAe;AAAA,YACb,GAAG,MAAM;AAAA,YACT,CAAC,cAAc,GAAG,CAAC;AAAA,UACrB;AAAA,QACF,EAAE;AAAA,MACJ;AAAA,MAEA,oBAAoB,MAAM;AACxB,YAAI,EAAE,eAAe,CAAC,EAAE,CAAC;AAAA,MAC3B;AAAA,MAEA,uBAAuB,CAAC,gBAAgB,YACtC,IAAI,EAAE,cAAc,cAAc,GAAG;AAAA,QAAK,CAAC,YACzC,cAAc,QAAQ,SAAS,OAAO;AAAA,MACxC,GAAG;AAAA,IACP;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,aAAS,qCAAkB,MAAM,cAAc;AAAA,IACjD;AAAA,EACF;AACF;","names":[]}

package/dist/cjs/client/EditionPanel/useEditedContentStore.d.ts

@@ -0,0 +1,28 @@
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { KeyPath } from '@intlayer/core';
+import { FileContent } from '@intlayer/design-system';
+
+type DictionaryPath = string;
+type EditedContent = Record<DictionaryPath, FileContent[]>;
+type EditedContentStore = {
+    editedContent: EditedContent;
+    addEditedContent: (dictionaryPath: DictionaryPath, keyPath: KeyPath[], newValue: string) => void;
+    removeEditedContent: (dictionaryPath: DictionaryPath, keyPath: KeyPath[]) => void;
+    clearEditedDictionaryContent: (dictionaryPath: DictionaryPath) => void;
+    clearEditedContent: () => void;
+    getEditedContentValue: (dictionaryPath: DictionaryPath, keyPath: KeyPath[]) => string | undefined;
+};
+declare const useEditedContentStore: zustand.UseBoundStore<Omit<zustand.StoreApi<EditedContentStore>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<EditedContentStore, EditedContentStore>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => void | Promise<void>;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: EditedContentStore) => void) => () => void;
+        onFinishHydration: (fn: (state: EditedContentStore) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<EditedContentStore, EditedContentStore>>;
+    };
+}>;
+
+export { type EditedContent, useEditedContentStore };