react-intlayer 1.0.0

package/dist/cjs/server/LocaleServerContextProvider.d.ts

@@ -0,0 +1,34 @@
+import * as react from "react";
+import { PropsWithChildren, FC } from "react";
+import { Locales } from "@intlayer/config/client";
+
+declare const LocaleServerContext: {
+  Provider: ({
+    children,
+    value,
+  }: {
+    children: react.ReactNode;
+    value: Locales;
+  }) => react.ReactNode;
+  Consumer: ({
+    children,
+  }: {
+    children: (context: Locales | undefined) => react.ReactNode;
+  }) => react.ReactNode;
+  _storage: () => {
+    value: Locales | undefined;
+  };
+  _defaultValue: Locales | undefined;
+};
+declare const locale: Locales | undefined;
+type LocaleServerContextProviderProps = PropsWithChildren & {
+  locale: Locales;
+};
+declare const LocaleServerContextProvider: FC<LocaleServerContextProviderProps>;
+
+export {
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  type LocaleServerContextProviderProps,
+  locale,
+};

package/dist/cjs/server/getLocaleTranslation.cjs

@@ -0,0 +1,50 @@
+"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 getLocaleTranslation_exports = {};
+__export(getLocaleTranslation_exports, {
+  getLocaleTranslation: () => getLocaleTranslation,
+});
+module.exports = __toCommonJS(getLocaleTranslation_exports);
+var import_client = require("@intlayer/config/client");
+var import_core = require("@intlayer/core");
+var import_LocaleServerContextProvider = require("./LocaleServerContextProvider.cjs");
+var import_serverContext = require("./serverContext.cjs");
+const getLocaleTranslation = (languageContent) => {
+  const locale = (0, import_serverContext.getServerContext)(
+    import_LocaleServerContextProvider.LocaleServerContext
+  );
+  const content = (0, import_core.getTranslationContent)(
+    languageContent,
+    locale ?? import_client.intlayerIntlConfiguration.defaultLocale
+  );
+  return {
+    locale,
+    content,
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    getLocaleTranslation,
+  });
+//# sourceMappingURL=getLocaleTranslation.cjs.map

package/dist/cjs/server/getLocaleTranslation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/getLocaleTranslation.ts"],"sourcesContent":["import { intlayerIntlConfiguration } from '@intlayer/config/client';\nimport { type LanguageContent, getTranslationContent } from '@intlayer/core';\nimport { LocaleServerContext } from './LocaleServerContextProvider';\nimport { getServerContext } from './serverContext';\n\nexport const getLocaleTranslation = <Content>(\n  languageContent: LanguageContent<Content>\n) => {\n  const locale = getServerContext(LocaleServerContext);\n  const content = getTranslationContent<Content>(\n    languageContent,\n    locale ?? intlayerIntlConfiguration.defaultLocale\n  );\n\n  return {\n    locale,\n    content,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA0C;AAC1C,kBAA4D;AAC5D,yCAAoC;AACpC,2BAAiC;AAE1B,MAAM,uBAAuB,CAClC,oBACG;AACH,QAAM,aAAS,uCAAiB,sDAAmB;AACnD,QAAM,cAAU;AAAA,IACd;AAAA,IACA,UAAU,wCAA0B;AAAA,EACtC;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/cjs/server/getLocaleTranslation.d.ts

@@ -0,0 +1,11 @@
+import * as _intlayer_config_client from "@intlayer/config/client";
+import { LanguageContent } from "@intlayer/core";
+
+declare const getLocaleTranslation: <Content>(
+  languageContent: LanguageContent<Content>
+) => {
+  locale: _intlayer_config_client.Locales | undefined;
+  content: Content;
+};
+
+export { getLocaleTranslation };

package/dist/cjs/server/index.cjs

@@ -0,0 +1,49 @@
+"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 server_exports = {};
+__export(server_exports, {
+  LocaleServerContext: () =>
+    import_LocaleServerContextProvider.LocaleServerContext,
+  LocaleServerContextProvider: () =>
+    import_LocaleServerContextProvider.LocaleServerContextProvider,
+  getLocaleContent: () => import_getLocaleTranslation.getLocaleTranslation,
+  locale: () => import_LocaleServerContextProvider.locale,
+  useIntlayer: () => import_useIntlayer.useIntlayer,
+  useTraduction: () => import_useTraduction.useTraduction,
+});
+module.exports = __toCommonJS(server_exports);
+var import_getLocaleTranslation = require("./getLocaleTranslation.cjs");
+var import_useTraduction = require("./useTraduction.cjs");
+var import_LocaleServerContextProvider = require("./LocaleServerContextProvider.cjs");
+var import_useIntlayer = require("./useIntlayer.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleServerContext,
+    LocaleServerContextProvider,
+    getLocaleContent,
+    locale,
+    useIntlayer,
+    useTraduction,
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/server/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/index.ts"],"sourcesContent":["export { getLocaleTranslation as getLocaleContent } from './getLocaleTranslation';\nexport { useTraduction } from './useTraduction';\nexport {\n  LocaleServerContext,\n  locale,\n  LocaleServerContextProvider,\n} from './LocaleServerContextProvider';\nexport { useIntlayer } from './useIntlayer';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kCAAyD;AACzD,2BAA8B;AAC9B,yCAIO;AACP,yBAA4B;","names":[]}

package/dist/cjs/server/index.d.ts

@@ -0,0 +1,13 @@
+export { getLocaleTranslation as getLocaleContent } from "./getLocaleTranslation.js";
+export { useTraduction } from "./useTraduction.js";
+export {
+  LocaleServerContext,
+  LocaleServerContextProvider,
+  locale,
+} from "./LocaleServerContextProvider.js";
+export { useIntlayer } from "./useIntlayer.js";
+import "@intlayer/config/client";
+import "@intlayer/core";
+import "react";
+import "../useIntlayerBase.js";
+import "intlayer";

package/dist/cjs/server/serverContext.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 serverContext_exports = {};
+__export(serverContext_exports, {
+  createServerContext: () => createServerContext,
+  getServerContext: () => getServerContext,
+});
+module.exports = __toCommonJS(serverContext_exports);
+var import_react = __toESM(require("react"));
+const cacheFallback = () => () => ({ value: void 0 });
+const createServerContext = (defaultValue) => {
+  throwInClient();
+  const cache = import_react.default.cache ?? cacheFallback;
+  const getCache = cache(() => ({
+    value: void 0,
+  }));
+  return {
+    Provider: ({ children, value }) => {
+      getCache().value = value;
+      return children;
+    },
+    Consumer: ({ children }) => {
+      const store = getCache();
+      return children(store ? store.value : defaultValue);
+    },
+    _storage: getCache,
+    _defaultValue: defaultValue,
+  };
+};
+const getServerContext = ({ _storage, _defaultValue }) => {
+  const store = _storage();
+  if (!store) return _defaultValue;
+  return store.value;
+};
+const throwInClient = () => {
+  if (typeof window !== "undefined") {
+    throw new Error(`createServerContext only works in Server Components`);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    createServerContext,
+    getServerContext,
+  });
+//# sourceMappingURL=serverContext.cjs.map

package/dist/cjs/server/serverContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/serverContext.ts"],"sourcesContent":["/**\n * Creates a new datastore for a given server context.\n * Attempts to closely mimic the `createContext` API.\n *\n * @example\n * const LocaleServerContext = createServerContext<string | null>(null);\n *\n * <LocaleServerContext.Provider value={locale}>\n *      {children}\n * </LocaleServerContext.Provider>\n */\n\nimport react from 'react';\n\ntype CacheType<T> = () => { value: T | undefined };\n\nconst cacheFallback = () => () => ({ value: undefined });\n\nexport const createServerContext = <T>(defaultValue?: T): ServerContext<T> => {\n  throwInClient();\n\n  const cache = react.cache<CacheType<T>> ?? cacheFallback;\n\n  const getCache = cache(() => ({\n    value: undefined,\n  }));\n\n  return {\n    Provider: ({ children, value }) => {\n      getCache().value = value;\n      return children;\n    },\n    Consumer: ({ children }) => {\n      const store = getCache();\n      return children(store ? store.value : defaultValue);\n    },\n    _storage: getCache,\n    _defaultValue: defaultValue,\n  };\n};\n\n/**\n * Fetches a value present in a given server context.\n * Attempts to closely mimic the `useContext` API.\n *\n * @example\n * getServerContext(LocaleServerContext);\n */\nexport const getServerContext = <T>({\n  _storage,\n  _defaultValue,\n}: ServerContext<T>) => {\n  // throwInClient();\n  const store = _storage();\n  if (!store) return _defaultValue;\n  return store.value;\n};\n\ntype ServerContext<T> = {\n  Provider: ({\n    children,\n    value,\n  }: {\n    children: React.ReactNode;\n    value: T;\n  }) => React.ReactNode;\n  Consumer: ({\n    children,\n  }: {\n    children: (context: T | undefined) => React.ReactNode;\n  }) => React.ReactNode;\n  _storage: () => { value: T | undefined };\n  _defaultValue: T | undefined;\n};\n\n/**\n * Throws if called within a client component environment.\n * Useful to help prevent mistakes.\n */\nconst throwInClient = (): void | never => {\n  // If window.document is defined we're in a client component\n  if (typeof window !== 'undefined') {\n    throw new Error(`createServerContext only works in Server Components`);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,mBAAkB;AAIlB,MAAM,gBAAgB,MAAM,OAAO,EAAE,OAAO,OAAU;AAE/C,MAAM,sBAAsB,CAAI,iBAAuC;AAC5E,gBAAc;AAEd,QAAM,QAAQ,aAAAA,QAAM,SAAuB;AAE3C,QAAM,WAAW,MAAM,OAAO;AAAA,IAC5B,OAAO;AAAA,EACT,EAAE;AAEF,SAAO;AAAA,IACL,UAAU,CAAC,EAAE,UAAU,MAAM,MAAM;AACjC,eAAS,EAAE,QAAQ;AACnB,aAAO;AAAA,IACT;AAAA,IACA,UAAU,CAAC,EAAE,SAAS,MAAM;AAC1B,YAAM,QAAQ,SAAS;AACvB,aAAO,SAAS,QAAQ,MAAM,QAAQ,YAAY;AAAA,IACpD;AAAA,IACA,UAAU;AAAA,IACV,eAAe;AAAA,EACjB;AACF;AASO,MAAM,mBAAmB,CAAI;AAAA,EAClC;AAAA,EACA;AACF,MAAwB;AAEtB,QAAM,QAAQ,SAAS;AACvB,MAAI,CAAC;AAAO,WAAO;AACnB,SAAO,MAAM;AACf;AAuBA,MAAM,gBAAgB,MAAoB;AAExC,MAAI,OAAO,WAAW,aAAa;AACjC,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AACF;","names":["react"]}

package/dist/cjs/server/serverContext.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Creates a new datastore for a given server context.
+ * Attempts to closely mimic the `createContext` API.
+ *
+ * @example
+ * const LocaleServerContext = createServerContext<string | null>(null);
+ *
+ * <LocaleServerContext.Provider value={locale}>
+ *      {children}
+ * </LocaleServerContext.Provider>
+ */
+declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
+/**
+ * Fetches a value present in a given server context.
+ * Attempts to closely mimic the `useContext` API.
+ *
+ * @example
+ * getServerContext(LocaleServerContext);
+ */
+declare const getServerContext: <T>({
+  _storage,
+  _defaultValue,
+}: ServerContext<T>) => T | undefined;
+type ServerContext<T> = {
+  Provider: ({
+    children,
+    value,
+  }: {
+    children: React.ReactNode;
+    value: T;
+  }) => React.ReactNode;
+  Consumer: ({
+    children,
+  }: {
+    children: (context: T | undefined) => React.ReactNode;
+  }) => React.ReactNode;
+  _storage: () => {
+    value: T | undefined;
+  };
+  _defaultValue: T | undefined;
+};
+
+export { createServerContext, getServerContext };

package/dist/cjs/server/useIntlayer.cjs

@@ -0,0 +1,44 @@
+"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 useIntlayer_exports = {};
+__export(useIntlayer_exports, {
+  useIntlayer: () => useIntlayer,
+});
+module.exports = __toCommonJS(useIntlayer_exports);
+var import_useIntlayerBase = require("../useIntlayerBase.cjs");
+var import_LocaleServerContextProvider = require("./LocaleServerContextProvider.cjs");
+var import_serverContext = require("./serverContext.cjs");
+const useIntlayer = (id, locale) => {
+  const localeTarget =
+    locale ??
+    (0, import_serverContext.getServerContext)(
+      import_LocaleServerContextProvider.LocaleServerContext
+    );
+  return (0, import_useIntlayerBase.useIntlayerBase)(id, localeTarget);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useIntlayer,
+  });
+//# sourceMappingURL=useIntlayer.cjs.map

package/dist/cjs/server/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/useIntlayer.ts"],"sourcesContent":["import type { Locales } from '@intlayer/config/client';\nimport {\n  type DictionaryKeys,\n  useIntlayerBase,\n  type UseIntlayer,\n} from '../useIntlayerBase';\nimport { LocaleServerContext } from './LocaleServerContextProvider';\nimport { getServerContext } from './serverContext';\n\nexport const useIntlayer: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const localeTarget = locale ?? getServerContext<Locales>(LocaleServerContext);\n\n  return useIntlayerBase(id, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,6BAIO;AACP,yCAAoC;AACpC,2BAAiC;AAE1B,MAAM,cAA2B,CACtC,IACA,WACG;AACH,QAAM,eAAe,cAAU,uCAA0B,sDAAmB;AAE5E,aAAO,wCAAgB,IAAI,YAAY;AACzC;","names":[]}

package/dist/cjs/server/useIntlayer.d.ts

@@ -0,0 +1,7 @@
+import { UseIntlayer } from "../useIntlayerBase.js";
+import "@intlayer/config/client";
+import "intlayer";
+
+declare const useIntlayer: UseIntlayer;
+
+export { useIntlayer };

package/dist/cjs/server/useTraduction.cjs

@@ -0,0 +1,42 @@
+"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 useTraduction_exports = {};
+__export(useTraduction_exports, {
+  useTraduction: () => useTraduction,
+});
+module.exports = __toCommonJS(useTraduction_exports);
+var import_getTranslation = require("../getTranslation.cjs");
+var import_LocaleServerContextProvider = require("./LocaleServerContextProvider.cjs");
+var import_serverContext = require("./serverContext.cjs");
+const useTraduction = (languageContent) => {
+  const locale = (0, import_serverContext.getServerContext)(
+    import_LocaleServerContextProvider.LocaleServerContext
+  );
+  return (0, import_getTranslation.getTranslation)(languageContent, locale);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useTraduction,
+  });
+//# sourceMappingURL=useTraduction.cjs.map

package/dist/cjs/server/useTraduction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/server/useTraduction.ts"],"sourcesContent":["import type { Locales } from '@intlayer/config/client';\nimport type { LanguageContent } from '@intlayer/core';\nimport { getTranslation } from '../getTranslation';\nimport { LocaleServerContext } from './LocaleServerContextProvider';\nimport { getServerContext } from './serverContext';\n\nexport const useTraduction = <Content>(\n  languageContent: LanguageContent<Content>\n) => {\n  const locale = getServerContext<Locales>(LocaleServerContext);\n\n  return getTranslation(languageContent, locale);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,4BAA+B;AAC/B,yCAAoC;AACpC,2BAAiC;AAE1B,MAAM,gBAAgB,CAC3B,oBACG;AACH,QAAM,aAAS,uCAA0B,sDAAmB;AAE5D,aAAO,sCAAe,iBAAiB,MAAM;AAC/C;","names":[]}

package/dist/cjs/server/useTraduction.d.ts

@@ -0,0 +1,7 @@
+import { LanguageContent } from "@intlayer/core";
+
+declare const useTraduction: <Content>(
+  languageContent: LanguageContent<Content>
+) => Content;
+
+export { useTraduction };

package/dist/cjs/useIntlayerBase.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 useIntlayerBase_exports = {};
+__export(useIntlayerBase_exports, {
+  useIntlayerBase: () => useIntlayerBase,
+});
+module.exports = __toCommonJS(useIntlayerBase_exports);
+var import_dictionaries_entry = __toESM(
+  require("@intlayer/dictionaries-entry")
+);
+var import_processDictionary = require("./processDictionary/index.cjs");
+const useIntlayerBase = (id, locale) => {
+  const dictionary = import_dictionaries_entry.default[id];
+  return (0, import_processDictionary.processDictionary)(dictionary, locale);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useIntlayerBase,
+  });
+//# sourceMappingURL=useIntlayerBase.cjs.map

package/dist/cjs/useIntlayerBase.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/useIntlayerBase.ts"],"sourcesContent":["/**\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 type { Locales } from '@intlayer/config/client';\nimport dictionaries from '@intlayer/dictionaries-entry';\nimport type { IntlayerDictionaryTypesConnector } from 'intlayer';\nimport type { Content } from './processDictionary/contentDictionary';\nimport { processDictionary } from './processDictionary/index';\n\nexport type StringFallback<T> = T extends never ? string : T; // If no keys are found, return string to disable error, and accept any string as dictionary key\nexport type DictionaryKeys = StringFallback<\n  keyof IntlayerDictionaryTypesConnector\n>;\n\nexport type UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => IntlayerDictionaryTypesConnector[T];\n\nexport const useIntlayerBase: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const dictionary: Content = dictionaries[id];\n\n  return processDictionary(\n    dictionary,\n    locale\n  ) as IntlayerDictionaryTypesConnector[T];\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,gCAAyB;AAGzB,+BAAkC;AAY3B,MAAM,kBAA+B,CAC1C,IACA,WACG;AACH,QAAM,aAAsB,0BAAAA,QAAa,EAAE;AAE3C,aAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;","names":["dictionaries"]}

package/dist/cjs/useIntlayerBase.d.ts

@@ -0,0 +1,23 @@
+import { Locales } from "@intlayer/config/client";
+import { IntlayerDictionaryTypesConnector } from "intlayer";
+
+/**
+ * @intlayer/dictionaries-entry is a package that only returns the dictionary entry path.
+ * Using an external package allow to alias it in the bundle configuration (such as webpack).
+ * The alias allow hot reload the app (such as nextjs) on any dictionary change.
+ */
+
+type StringFallback<T> = T extends never ? string : T;
+type DictionaryKeys = StringFallback<keyof IntlayerDictionaryTypesConnector>;
+type UseIntlayer = <T extends DictionaryKeys>(
+  id: T,
+  locale?: Locales
+) => IntlayerDictionaryTypesConnector[T];
+declare const useIntlayerBase: UseIntlayer;
+
+export {
+  type DictionaryKeys,
+  type StringFallback,
+  type UseIntlayer,
+  useIntlayerBase,
+};

package/dist/esm/ContentEditor/ContentEditor.d.mts

@@ -0,0 +1,8 @@
+import { FC } from "react";
+
+type ContentEditorProps = {
+  children?: string;
+};
+declare const ContentEditor: FC<ContentEditorProps>;
+
+export { ContentEditor };

package/dist/esm/ContentEditor/ContentEditor.mjs

@@ -0,0 +1,82 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useState, useRef, useCallback } from "react";
+const PRESS_DETECT_DURATION = 500;
+const ContentEditor = ({ children }) => {
+  const divRef = useRef(null);
+  const [isEditing, setIsEditing] = useState(false);
+  const pressTimerRef = useRef(null);
+  const handleOnLongPress = () => {
+    setIsEditing(true);
+  };
+  const startPressTimer = () => {
+    pressTimerRef.current = setTimeout(() => {
+      handleOnLongPress();
+    }, PRESS_DETECT_DURATION);
+  };
+  const clearPressTimer = () => {
+    if (pressTimerRef.current) {
+      clearTimeout(pressTimerRef.current);
+      pressTimerRef.current = null;
+    }
+  };
+  const handleMouseDown = () => {
+    clearPressTimer();
+    startPressTimer();
+  };
+  const handleMouseUp = () => {
+    clearPressTimer();
+  };
+  const handleClickOutside = useCallback(
+    (event) => {
+      if (divRef.current && !divRef.current.contains(event.target)) {
+        setIsEditing(false);
+      }
+    },
+    [divRef]
+  );
+  useEffect(() => {
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      clearPressTimer();
+    };
+  }, [handleClickOutside]);
+  const handleOnClick = (e) => {
+    if (isEditing) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+  };
+  const handleOnBlur = () => {
+    setIsEditing(false);
+  };
+  const onContentChange = (_e) => {};
+  return /* @__PURE__ */ jsx("div", {
+    role: "textbox",
+    tabIndex: 0,
+    onKeyUp: () => null,
+    contentEditable: isEditing,
+    onInput: onContentChange,
+    onClick: handleOnClick,
+    onMouseDown: handleMouseDown,
+    onMouseUp: handleMouseUp,
+    onMouseLeave: handleMouseUp,
+    onTouchStart: handleMouseDown,
+    onTouchEnd: handleMouseUp,
+    onTouchCancel: handleMouseUp,
+    onBlur: handleOnBlur,
+    suppressContentEditableWarning: true,
+    style: isEditing
+      ? {
+          backgroundColor: "transparent",
+          cursor: "text",
+          display: "inline",
+        }
+      : { cursor: "pointer", display: "inline" },
+    ref: divRef,
+    children,
+  });
+};
+export { ContentEditor };
+//# sourceMappingURL=ContentEditor.mjs.map

package/dist/esm/ContentEditor/ContentEditor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ContentEditor/ContentEditor.tsx"],"sourcesContent":["'use client';\n\nimport {\n  useEffect,\n  useState,\n  useRef,\n  useCallback,\n  type FC,\n  type MouseEventHandler,\n} from 'react';\n\ntype ContentEditorProps = {\n  children?: string;\n};\n\nconst PRESS_DETECT_DURATION = 500;\n\nexport const ContentEditor: FC<ContentEditorProps> = ({ children }) => {\n  const divRef = useRef<HTMLDivElement>(null);\n  const [isEditing, setIsEditing] = useState(false);\n  const pressTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  const handleOnLongPress = () => {\n    setIsEditing(true);\n  };\n\n  const startPressTimer = () => {\n    pressTimerRef.current = setTimeout(() => {\n      handleOnLongPress();\n    }, PRESS_DETECT_DURATION);\n  };\n\n  const clearPressTimer = () => {\n    if (pressTimerRef.current) {\n      clearTimeout(pressTimerRef.current);\n      pressTimerRef.current = null;\n    }\n  };\n\n  const handleMouseDown = () => {\n    clearPressTimer(); // Ensure any previous timer is cleared\n    startPressTimer();\n  };\n\n  const handleMouseUp = () => {\n    clearPressTimer();\n  };\n\n  // Use useCallback to ensure the function identity remains stable\n  const handleClickOutside = useCallback(\n    (event: MouseEvent) => {\n      if (divRef.current && !divRef.current.contains(event.target as Node)) {\n        setIsEditing(false);\n      }\n    },\n    [divRef]\n  );\n\n  useEffect(() => {\n    // Attach click outside listener\n    document.addEventListener('mousedown', handleClickOutside);\n\n    return () => {\n      // Cleanup\n      document.removeEventListener('mousedown', handleClickOutside);\n      clearPressTimer(); // Ensure to clear the timer when component unmounts\n    };\n  }, [handleClickOutside]);\n\n  const handleOnClick: MouseEventHandler<HTMLDivElement> = (e) => {\n    if (isEditing) {\n      e.preventDefault();\n      e.stopPropagation();\n    }\n  };\n\n  const handleOnBlur = () => {\n    // Stop editing when the element loses focus\n    setIsEditing(false);\n  };\n\n  const onContentChange = (_e: React.FormEvent<HTMLDivElement>) => {\n    // console.log(e.currentTarget.textContent);\n  };\n\n  return (\n    <div\n      role=\"textbox\"\n      tabIndex={0}\n      onKeyUp={() => null}\n      contentEditable={isEditing}\n      onInput={onContentChange}\n      onClick={handleOnClick}\n      onMouseDown={handleMouseDown}\n      onMouseUp={handleMouseUp}\n      onMouseLeave={handleMouseUp}\n      onTouchStart={handleMouseDown}\n      onTouchEnd={handleMouseUp}\n      onTouchCancel={handleMouseUp}\n      onBlur={handleOnBlur}\n      suppressContentEditableWarning={true} // To suppress the warning for controlled components\n      style={\n        isEditing\n          ? {\n              backgroundColor: 'transparent',\n              cursor: 'text',\n              display: 'inline',\n            }\n          : { cursor: 'pointer', display: 'inline' }\n      }\n      ref={divRef}\n    >\n      {children}\n    </div>\n  );\n};\n"],"mappings":";AAsFI;AApFJ;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AAMP,MAAM,wBAAwB;AAEvB,MAAM,gBAAwC,CAAC,EAAE,SAAS,MAAM;AACrE,QAAM,SAAS,OAAuB,IAAI;AAC1C,QAAM,CAAC,WAAW,YAAY,IAAI,SAAS,KAAK;AAChD,QAAM,gBAAgB,OAA6C,IAAI;AAEvE,QAAM,oBAAoB,MAAM;AAC9B,iBAAa,IAAI;AAAA,EACnB;AAEA,QAAM,kBAAkB,MAAM;AAC5B,kBAAc,UAAU,WAAW,MAAM;AACvC,wBAAkB;AAAA,IACpB,GAAG,qBAAqB;AAAA,EAC1B;AAEA,QAAM,kBAAkB,MAAM;AAC5B,QAAI,cAAc,SAAS;AACzB,mBAAa,cAAc,OAAO;AAClC,oBAAc,UAAU;AAAA,IAC1B;AAAA,EACF;AAEA,QAAM,kBAAkB,MAAM;AAC5B,oBAAgB;AAChB,oBAAgB;AAAA,EAClB;AAEA,QAAM,gBAAgB,MAAM;AAC1B,oBAAgB;AAAA,EAClB;AAGA,QAAM,qBAAqB;AAAA,IACzB,CAAC,UAAsB;AACrB,UAAI,OAAO,WAAW,CAAC,OAAO,QAAQ,SAAS,MAAM,MAAc,GAAG;AACpE,qBAAa,KAAK;AAAA,MACpB;AAAA,IACF;AAAA,IACA,CAAC,MAAM;AAAA,EACT;AAEA,YAAU,MAAM;AAEd,aAAS,iBAAiB,aAAa,kBAAkB;AAEzD,WAAO,MAAM;AAEX,eAAS,oBAAoB,aAAa,kBAAkB;AAC5D,sBAAgB;AAAA,IAClB;AAAA,EACF,GAAG,CAAC,kBAAkB,CAAC;AAEvB,QAAM,gBAAmD,CAAC,MAAM;AAC9D,QAAI,WAAW;AACb,QAAE,eAAe;AACjB,QAAE,gBAAgB;AAAA,IACpB;AAAA,EACF;AAEA,QAAM,eAAe,MAAM;AAEzB,iBAAa,KAAK;AAAA,EACpB;AAEA,QAAM,kBAAkB,CAAC,OAAwC;AAAA,EAEjE;AAEA,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,UAAU;AAAA,MACV,SAAS,MAAM;AAAA,MACf,iBAAiB;AAAA,MACjB,SAAS;AAAA,MACT,SAAS;AAAA,MACT,aAAa;AAAA,MACb,WAAW;AAAA,MACX,cAAc;AAAA,MACd,cAAc;AAAA,MACd,YAAY;AAAA,MACZ,eAAe;AAAA,MACf,QAAQ;AAAA,MACR,gCAAgC;AAAA,MAChC,OACE,YACI;AAAA,QACE,iBAAiB;AAAA,QACjB,QAAQ;AAAA,QACR,SAAS;AAAA,MACX,IACA,EAAE,QAAQ,WAAW,SAAS,SAAS;AAAA,MAE7C,KAAK;AAAA,MAEJ;AAAA;AAAA,EACH;AAEJ;","names":[]}

package/dist/esm/ContentEditor/contentRender.d.mts

@@ -0,0 +1,3 @@
+declare const contentRender: (content: string) => string;
+
+export { contentRender };

package/dist/esm/ContentEditor/contentRender.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { ContentEditor } from "./ContentEditor.mjs";
+const contentRender = (content) => {
+  const isEditable = process.env.NODE_ENV === "development";
+  if (isEditable && ContentEditor) {
+    return /* @__PURE__ */ jsx(ContentEditor, { children: content });
+  }
+  return content;
+};
+export { contentRender };
+//# sourceMappingURL=contentRender.mjs.map

package/dist/esm/ContentEditor/contentRender.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ContentEditor/contentRender.tsx"],"sourcesContent":["import { ContentEditor } from './ContentEditor';\n\nexport const contentRender = (content: string) => {\n  const isEditable = process.env.NODE_ENV === 'development';\n\n  if (isEditable && ContentEditor) {\n    return (<ContentEditor>{content}</ContentEditor>) as unknown as string;\n  }\n\n  return content;\n};\n"],"mappings":"AAMY;AANZ,SAAS,qBAAqB;AAEvB,MAAM,gBAAgB,CAAC,YAAoB;AAChD,QAAM,aAAa,QAAQ,IAAI,aAAa;AAE5C,MAAI,cAAc,eAAe;AAC/B,WAAQ,oBAAC,iBAAe,mBAAQ;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/ContentEditor/index.d.mts

@@ -0,0 +1,3 @@
+export { ContentEditor } from "./ContentEditor.mjs";
+export { contentRender } from "./contentRender.mjs";
+import "react";

package/dist/esm/ContentEditor/index.mjs

@@ -0,0 +1,3 @@
+export * from "./ContentEditor.mjs";
+export * from "./contentRender.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/esm/ContentEditor/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/ContentEditor/index.tsx"],"sourcesContent":["export * from './ContentEditor';\nexport * from './contentRender';\n"],"mappings":"AAAA,cAAc;AACd,cAAc;","names":[]}

package/dist/esm/LocaleContextProvider.d.mts

@@ -0,0 +1,10 @@
+import { FC } from "react";
+import { LocaleClientContextProviderProps } from "./client/LocaleClientContextProvider.mjs";
+import { LocaleServerContextProviderProps } from "./server/LocaleServerContextProvider.mjs";
+import "@intlayer/config/client";
+
+type LocaleContextProviderProps = LocaleClientContextProviderProps &
+  LocaleServerContextProviderProps;
+declare const LocaleContextProvider: FC<LocaleContextProviderProps>;
+
+export { LocaleContextProvider };