react-intlayer 1.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/dist/cjs/ContentEditor/ContentEditor.cjs

@@ -0,0 +1,113 @@
+"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 ContentEditor_exports = {};
+__export(ContentEditor_exports, {
+  ContentEditor: () => ContentEditor,
+});
+module.exports = __toCommonJS(ContentEditor_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+const PRESS_DETECT_DURATION = 500;
+const ContentEditor = ({ children }) => {
+  const divRef = (0, import_react.useRef)(null);
+  const [isEditing, setIsEditing] = (0, import_react.useState)(false);
+  const pressTimerRef = (0, import_react.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 = (0, import_react.useCallback)(
+    (event) => {
+      if (divRef.current && !divRef.current.contains(event.target)) {
+        setIsEditing(false);
+      }
+    },
+    [divRef]
+  );
+  (0, import_react.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__ */ (0, import_jsx_runtime.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,
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    ContentEditor,
+  });
+//# sourceMappingURL=ContentEditor.cjs.map

package/dist/cjs/ContentEditor/ContentEditor.cjs.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":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsFI;AApFJ,mBAOO;AAMP,MAAM,wBAAwB;AAEvB,MAAM,gBAAwC,CAAC,EAAE,SAAS,MAAM;AACrE,QAAM,aAAS,qBAAuB,IAAI;AAC1C,QAAM,CAAC,WAAW,YAAY,QAAI,uBAAS,KAAK;AAChD,QAAM,oBAAgB,qBAA6C,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,yBAAqB;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,8BAAU,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/cjs/ContentEditor/ContentEditor.d.ts

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

package/dist/cjs/ContentEditor/contentRender.cjs

@@ -0,0 +1,45 @@
+"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 contentRender_exports = {};
+__export(contentRender_exports, {
+  contentRender: () => contentRender,
+});
+module.exports = __toCommonJS(contentRender_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_ContentEditor = require("./ContentEditor.cjs");
+const contentRender = (content) => {
+  const isEditable = process.env.NODE_ENV === "development";
+  if (isEditable && import_ContentEditor.ContentEditor) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_ContentEditor.ContentEditor,
+      { children: content }
+    );
+  }
+  return content;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    contentRender,
+  });
+//# sourceMappingURL=contentRender.cjs.map

package/dist/cjs/ContentEditor/contentRender.cjs.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":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMY;AANZ,2BAA8B;AAEvB,MAAM,gBAAgB,CAAC,YAAoB;AAChD,QAAM,aAAa,QAAQ,IAAI,aAAa;AAE5C,MAAI,cAAc,oCAAe;AAC/B,WAAQ,4CAAC,sCAAe,mBAAQ;AAAA,EAClC;AAEA,SAAO;AACT;","names":[]}

package/dist/cjs/ContentEditor/contentRender.d.ts

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

package/dist/cjs/ContentEditor/index.cjs

@@ -0,0 +1,41 @@
+"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 ContentEditor_exports = {};
+module.exports = __toCommonJS(ContentEditor_exports);
+__reExport(
+  ContentEditor_exports,
+  require("./ContentEditor.cjs"),
+  module.exports
+);
+__reExport(
+  ContentEditor_exports,
+  require("./contentRender.cjs"),
+  module.exports
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    ...require("./ContentEditor.cjs"),
+    ...require("./contentRender.cjs"),
+  });
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/ContentEditor/index.cjs.map

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

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

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

package/dist/cjs/LocaleContextProvider.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 LocaleContextProvider_exports = {};
+__export(LocaleContextProvider_exports, {
+  LocaleContextProvider: () => LocaleContextProvider,
+});
+module.exports = __toCommonJS(LocaleContextProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = require("@intlayer/config/client");
+var import_LocaleClientContextProvider = require("./client/LocaleClientContextProvider.cjs");
+var import_LocaleServerContextProvider = require("./server/LocaleServerContextProvider.cjs");
+const defaultLocale = import_client.intlayerIntlConfiguration.defaultLocale;
+const LocaleContextProvider = ({ children, locale = defaultLocale }) =>
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_LocaleServerContextProvider.LocaleServerContextProvider,
+    {
+      locale,
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_LocaleClientContextProvider.LocaleClientContextProvider,
+        { locale, children }
+      ),
+    }
+  );
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleContextProvider,
+  });
+//# sourceMappingURL=LocaleContextProvider.cjs.map

package/dist/cjs/LocaleContextProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/LocaleContextProvider.tsx"],"sourcesContent":["import { intlayerIntlConfiguration } from '@intlayer/config/client';\nimport React, { type FC } from 'react';\nimport {\n  LocaleClientContextProvider,\n  type LocaleClientContextProviderProps,\n} from './client/LocaleClientContextProvider';\nimport {\n  LocaleServerContextProvider,\n  type LocaleServerContextProviderProps,\n} from './server/LocaleServerContextProvider';\n\nconst defaultLocale = intlayerIntlConfiguration.defaultLocale;\n\ntype LocaleContextProviderProps = LocaleClientContextProviderProps &\n  LocaleServerContextProviderProps;\n\nexport const LocaleContextProvider: FC<LocaleContextProviderProps> = ({\n  children,\n  locale = defaultLocale,\n}) => (\n  <LocaleServerContextProvider locale={locale}>\n    <LocaleClientContextProvider locale={locale}>\n      {children}\n    </LocaleClientContextProvider>\n  </LocaleServerContextProvider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBI;AArBJ,oBAA0C;AAE1C,yCAGO;AACP,yCAGO;AAEP,MAAM,gBAAgB,wCAA0B;AAKzC,MAAM,wBAAwD,CAAC;AAAA,EACpE;AAAA,EACA,SAAS;AACX,MACE,4CAAC,kEAA4B,QAC3B,sDAAC,kEAA4B,QAC1B,UACH,GACF;","names":[]}

package/dist/cjs/LocaleContextProvider.d.ts

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

package/dist/cjs/client/LocaleClientContextProvider.cjs

@@ -0,0 +1,54 @@
+"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 LocaleClientContextProvider_exports = {};
+__export(LocaleClientContextProvider_exports, {
+  LocaleClientContext: () => LocaleClientContext,
+  LocaleClientContextProvider: () => LocaleClientContextProvider,
+  useLocaleContext: () => useLocaleContext,
+});
+module.exports = __toCommonJS(LocaleClientContextProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_client = require("@intlayer/config/client");
+var import_react = require("react");
+var import_useLocaleCookie = require("./useLocaleCookie.cjs");
+const LocaleClientContext = (0, import_react.createContext)({
+  locale:
+    import_useLocaleCookie.localeCookie ??
+    import_client.intlayerIntlConfiguration.defaultLocale,
+});
+const useLocaleContext = () =>
+  (0, import_react.useContext)(LocaleClientContext);
+const LocaleClientContextProvider = ({ locale, children }) =>
+  /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocaleClientContext.Provider, {
+    value: { locale },
+    children,
+  });
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleClientContext,
+    LocaleClientContextProvider,
+    useLocaleContext,
+  });
+//# sourceMappingURL=LocaleClientContextProvider.cjs.map

package/dist/cjs/client/LocaleClientContextProvider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/LocaleClientContextProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n  intlayerIntlConfiguration,\n  type Locales,\n} from '@intlayer/config/client';\nimport {\n  type PropsWithChildren,\n  createContext,\n  useContext,\n  type FC,\n} from 'react';\nimport { localeCookie } from './useLocaleCookie';\n\ntype LocaleContextValue = {\n  locale: Locales;\n};\n\nexport const LocaleClientContext = createContext<LocaleContextValue>({\n  locale: localeCookie ?? intlayerIntlConfiguration.defaultLocale,\n});\n\nexport const useLocaleContext = () => useContext(LocaleClientContext);\n\nexport type LocaleClientContextProviderProps = PropsWithChildren & {\n  locale: Locales;\n};\n\nexport const LocaleClientContextProvider: FC<\n  LocaleClientContextProviderProps\n> = ({ locale, children }) => (\n  <LocaleClientContext.Provider value={{ locale }}>\n    {children}\n  </LocaleClientContext.Provider>\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA+BE;AA7BF,oBAGO;AACP,mBAKO;AACP,6BAA6B;AAMtB,MAAM,0BAAsB,4BAAkC;AAAA,EACnE,QAAQ,uCAAgB,wCAA0B;AACpD,CAAC;AAEM,MAAM,mBAAmB,UAAM,yBAAW,mBAAmB;AAM7D,MAAM,8BAET,CAAC,EAAE,QAAQ,SAAS,MACtB,4CAAC,oBAAoB,UAApB,EAA6B,OAAO,EAAE,OAAO,GAC3C,UACH;","names":[]}

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

@@ -0,0 +1,20 @@
+import * as react from "react";
+import { PropsWithChildren, FC } from "react";
+import { Locales } from "@intlayer/config/client";
+
+type LocaleContextValue = {
+  locale: Locales;
+};
+declare const LocaleClientContext: react.Context<LocaleContextValue>;
+declare const useLocaleContext: () => LocaleContextValue;
+type LocaleClientContextProviderProps = PropsWithChildren & {
+  locale: Locales;
+};
+declare const LocaleClientContextProvider: FC<LocaleClientContextProviderProps>;
+
+export {
+  LocaleClientContext,
+  LocaleClientContextProvider,
+  type LocaleClientContextProviderProps,
+  useLocaleContext,
+};

package/dist/cjs/client/index.cjs

@@ -0,0 +1,56 @@
+"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 client_exports = {};
+__export(client_exports, {
+  LocaleClientContext: () =>
+    import_LocaleClientContextProvider.LocaleClientContext,
+  LocaleClientContextProvider: () =>
+    import_LocaleClientContextProvider.LocaleClientContextProvider,
+  localeCookie: () => import_useLocaleCookie.localeCookie,
+  setLocaleCookie: () => import_useLocaleCookie.setLocaleCookie,
+  useIntlayer: () => import_useIntlayer.useIntlayer,
+  useLocale: () => import_useLocale.useLocale,
+  useLocaleContext: () => import_LocaleClientContextProvider.useLocaleContext,
+  useLocaleCookie: () => import_useLocaleCookie.useLocaleCookie,
+  useTraduction: () => import_useTraduction.useTraduction,
+});
+module.exports = __toCommonJS(client_exports);
+var import_LocaleClientContextProvider = require("./LocaleClientContextProvider.cjs");
+var import_useIntlayer = require("./useIntlayer.cjs");
+var import_useLocale = require("./useLocale.cjs");
+var import_useTraduction = require("./useTraduction.cjs");
+var import_useLocaleCookie = require("./useLocaleCookie.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    LocaleClientContext,
+    LocaleClientContextProvider,
+    localeCookie,
+    setLocaleCookie,
+    useIntlayer,
+    useLocale,
+    useLocaleContext,
+    useLocaleCookie,
+    useTraduction,
+  });
+//# sourceMappingURL=index.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/index.ts"],"sourcesContent":["export type { LocaleClientContextProviderProps } from './LocaleClientContextProvider';\nexport {\n  LocaleClientContext,\n  useLocaleContext,\n  LocaleClientContextProvider,\n} from './LocaleClientContextProvider';\nexport { useIntlayer } from './useIntlayer';\nexport { useLocale } from './useLocale';\nexport { useTraduction } from './useTraduction';\nexport {\n  useLocaleCookie,\n  localeCookie,\n  setLocaleCookie,\n} from './useLocaleCookie';\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,yCAIO;AACP,yBAA4B;AAC5B,uBAA0B;AAC1B,2BAA8B;AAC9B,6BAIO;","names":[]}

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

@@ -0,0 +1,19 @@
+export {
+  LocaleClientContext,
+  LocaleClientContextProvider,
+  LocaleClientContextProviderProps,
+  useLocaleContext,
+} from "./LocaleClientContextProvider.js";
+export { useIntlayer } from "./useIntlayer.js";
+export { useLocale } from "./useLocale.js";
+export { useTraduction } from "./useTraduction.js";
+export {
+  localeCookie,
+  setLocaleCookie,
+  useLocaleCookie,
+} from "./useLocaleCookie.js";
+import "react";
+import "@intlayer/config/client";
+import "../useIntlayerBase.js";
+import "intlayer";
+import "@intlayer/core";

package/dist/cjs/client/useContent.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 useContent_exports = {};
+__export(useContent_exports, {
+  useContent: () => useContent,
+});
+module.exports = __toCommonJS(useContent_exports);
+var import_useLocale = require("./useLocale.cjs");
+var import_useTraduction = require("./useTraduction.cjs");
+const useContent = (languageContent) => {
+  const { locale } = (0, import_useLocale.useLocale)();
+  const content = (0, import_useTraduction.useTraduction)(languageContent);
+  return {
+    locale,
+    content,
+    t: import_useTraduction.useTraduction,
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 &&
+  (module.exports = {
+    useContent,
+  });
+//# sourceMappingURL=useContent.cjs.map

package/dist/cjs/client/useContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useContent.ts"],"sourcesContent":["import type { LanguageContent } from '@intlayer/core';\nimport { useLocale } from './useLocale';\nimport { useTraduction } from './useTraduction';\n\nexport const useContent = <Content>(\n  languageContent: LanguageContent<Content>\n) => {\n  const { locale } = useLocale();\n\n  const content = useTraduction(languageContent);\n\n  return {\n    locale,\n    content,\n    t: useTraduction,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,uBAA0B;AAC1B,2BAA8B;AAEvB,MAAM,aAAa,CACxB,oBACG;AACH,QAAM,EAAE,OAAO,QAAI,4BAAU;AAE7B,QAAM,cAAU,oCAAc,eAAe;AAE7C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,GAAG;AAAA,EACL;AACF;","names":[]}

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

@@ -0,0 +1,12 @@
+import * as intlayer from "intlayer";
+import { LanguageContent } from "@intlayer/core";
+
+declare const useContent: <Content>(
+  languageContent: LanguageContent<Content>
+) => {
+  locale: intlayer.Locales;
+  content: Content;
+  t: <Content_1>(languageContent: LanguageContent<Content_1>) => Content_1;
+};
+
+export { useContent };

package/dist/cjs/client/useIntlayer.cjs

@@ -0,0 +1,44 @@
+"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 useIntlayer_exports = {};
+__export(useIntlayer_exports, {
+  useIntlayer: () => useIntlayer,
+});
+module.exports = __toCommonJS(useIntlayer_exports);
+var import_react = require("react");
+var import_useIntlayerBase = require("../useIntlayerBase.cjs");
+var import_LocaleClientContextProvider = require("./LocaleClientContextProvider.cjs");
+const useIntlayer = (id, locale) => {
+  const { locale: currentLocale } = (0, import_react.useContext)(
+    import_LocaleClientContextProvider.LocaleClientContext
+  );
+  const localeTarget = locale ?? currentLocale;
+  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/client/useIntlayer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useIntlayer.ts"],"sourcesContent":["'use client';\n\nimport type { Locales } from '@intlayer/config/client';\nimport { useContext } from 'react';\nimport {\n  type DictionaryKeys,\n  useIntlayerBase,\n  type UseIntlayer,\n} from '../useIntlayerBase';\nimport { LocaleClientContext } from './LocaleClientContextProvider';\n\nexport const useIntlayer: UseIntlayer = <T extends DictionaryKeys>(\n  id: T,\n  locale?: Locales\n) => {\n  const { locale: currentLocale } = useContext(LocaleClientContext);\n  const localeTarget = locale ?? currentLocale;\n\n  return useIntlayerBase(id, localeTarget);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,mBAA2B;AAC3B,6BAIO;AACP,yCAAoC;AAE7B,MAAM,cAA2B,CACtC,IACA,WACG;AACH,QAAM,EAAE,QAAQ,cAAc,QAAI,yBAAW,sDAAmB;AAChE,QAAM,eAAe,UAAU;AAE/B,aAAO,wCAAgB,IAAI,YAAY;AACzC;","names":[]}

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

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