@croct/plug-react 0.10.0 → 0.11.0

package/hooks/Cache.cjs

@@ -0,0 +1,88 @@
+"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 Cache_exports = {};
+__export(Cache_exports, {
+  Cache: () => Cache
+});
+module.exports = __toCommonJS(Cache_exports);
+class Cache {
+  constructor(defaultExpiration) {
+    this.cache = {};
+    this.defaultExpiration = defaultExpiration;
+  }
+  load(configuration) {
+    const { cacheKey, loader, fallback, expiration = this.defaultExpiration } = configuration;
+    const cachedEntry = this.get(cacheKey);
+    if (cachedEntry !== void 0) {
+      if (cachedEntry.error !== void 0) {
+        if (fallback !== void 0) {
+          return fallback;
+        }
+        if (cachedEntry.result === void 0) {
+          throw cachedEntry.error;
+        }
+      }
+      if (cachedEntry.result !== void 0) {
+        return cachedEntry.result;
+      }
+      throw cachedEntry.promise;
+    }
+    const entry = {
+      dispose: () => {
+        if (entry.timeout !== void 0 || expiration < 0) {
+          return;
+        }
+        entry.timeout = window.setTimeout(
+          () => {
+            delete this.cache[cacheKey];
+          },
+          expiration
+        );
+      },
+      promise: loader().then((result) => {
+        entry.result = result;
+        return result;
+      }).catch((error) => {
+        entry.result = fallback;
+        entry.error = error;
+        return fallback;
+      }).finally(() => {
+        entry.dispose();
+      })
+    };
+    this.cache[cacheKey] = entry;
+    throw entry.promise;
+  }
+  get(cacheKey) {
+    const entry = this.cache[cacheKey];
+    if (entry === void 0) {
+      return void 0;
+    }
+    if (entry.timeout !== void 0) {
+      clearTimeout(entry.timeout);
+      delete entry.timeout;
+      entry.dispose();
+    }
+    return entry;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache
+});

package/hooks/Cache.d.cts

@@ -0,0 +1,9 @@
+type EntryLoader<R> = (...args: any) => Promise<R>;
+type EntryOptions<R> = {
+    cacheKey: string;
+    loader: EntryLoader<R>;
+    fallback?: R;
+    expiration?: number;
+};
+
+export type { EntryLoader, EntryOptions };

package/hooks/Cache.d.ts

@@ -1,22 +1,9 @@
-export type EntryLoader<R> = (...args: any) => Promise<R>;
-export type EntryOptions<R> = {
+type EntryLoader<R> = (...args: any) => Promise<R>;
+type EntryOptions<R> = {
     cacheKey: string;
     loader: EntryLoader<R>;
     fallback?: R;
     expiration?: number;
 };
-type Entry<R = any> = {
-    promise: Promise<any>;
-    result?: R;
-    dispose: () => void;
-    timeout?: number;
-    error?: any;
-};
-export declare class Cache {
-    private readonly cache;
-    private readonly defaultExpiration;
-    constructor(defaultExpiration: number);
-    load<R>(configuration: EntryOptions<R>): R;
-    get<R>(cacheKey: string): Entry<R> | undefined;
-}
-export {};
+
+export type { EntryLoader, EntryOptions };

package/hooks/Cache.js

@@ -1,62 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cache = void 0;
 class Cache {
-    constructor(defaultExpiration) {
-        this.cache = {};
-        this.defaultExpiration = defaultExpiration;
-    }
-    load(configuration) {
-        const { cacheKey, loader, fallback, expiration = this.defaultExpiration } = configuration;
-        const cachedEntry = this.get(cacheKey);
-        if (cachedEntry !== undefined) {
-            if (cachedEntry.error !== undefined) {
-                if (fallback !== undefined) {
-                    return fallback;
-                }
-                throw cachedEntry.error;
-            }
-            if (cachedEntry.result !== undefined) {
-                return cachedEntry.result;
-            }
-            throw cachedEntry.promise;
+  constructor(defaultExpiration) {
+    this.cache = {};
+    this.defaultExpiration = defaultExpiration;
+  }
+  load(configuration) {
+    const { cacheKey, loader, fallback, expiration = this.defaultExpiration } = configuration;
+    const cachedEntry = this.get(cacheKey);
+    if (cachedEntry !== void 0) {
+      if (cachedEntry.error !== void 0) {
+        if (fallback !== void 0) {
+          return fallback;
         }
-        const entry = {
-            dispose: () => {
-                if (entry.timeout !== undefined || expiration < 0) {
-                    return;
-                }
-                entry.timeout = window.setTimeout(() => {
-                    delete this.cache[cacheKey];
-                }, expiration);
-            },
-            promise: loader()
-                .then((result) => {
-                entry.result = result;
-                return result;
-            })
-                .catch(error => {
-                entry.error = error;
-            })
-                .finally(() => {
-                entry.dispose();
-            }),
-        };
-        this.cache[cacheKey] = entry;
-        throw entry.promise;
-    }
-    get(cacheKey) {
-        const entry = this.cache[cacheKey];
-        if (entry === undefined) {
-            return undefined;
+        if (cachedEntry.result === void 0) {
+          throw cachedEntry.error;
         }
-        if (entry.timeout !== undefined) {
-            clearTimeout(entry.timeout);
-            delete entry.timeout;
-            entry.dispose();
+      }
+      if (cachedEntry.result !== void 0) {
+        return cachedEntry.result;
+      }
+      throw cachedEntry.promise;
+    }
+    const entry = {
+      dispose: () => {
+        if (entry.timeout !== void 0 || expiration < 0) {
+          return;
         }
-        return entry;
+        entry.timeout = window.setTimeout(
+          () => {
+            delete this.cache[cacheKey];
+          },
+          expiration
+        );
+      },
+      promise: loader().then((result) => {
+        entry.result = result;
+        return result;
+      }).catch((error) => {
+        entry.result = fallback;
+        entry.error = error;
+        return fallback;
+      }).finally(() => {
+        entry.dispose();
+      })
+    };
+    this.cache[cacheKey] = entry;
+    throw entry.promise;
+  }
+  get(cacheKey) {
+    const entry = this.cache[cacheKey];
+    if (entry === void 0) {
+      return void 0;
+    }
+    if (entry.timeout !== void 0) {
+      clearTimeout(entry.timeout);
+      delete entry.timeout;
+      entry.dispose();
     }
+    return entry;
+  }
 }
-exports.Cache = Cache;
-//# sourceMappingURL=Cache.js.map
+export {
+  Cache
+};

package/hooks/index.cjs

@@ -0,0 +1,26 @@
+"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 hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);
+__reExport(hooks_exports, require('./useEvaluation.cjs'), module.exports);
+__reExport(hooks_exports, require('./useContent.cjs'), module.exports);
+__reExport(hooks_exports, require('./useCroct.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require('./useEvaluation.cjs'),
+  ...require('./useContent.cjs'),
+  ...require('./useCroct.cjs')
+});

package/hooks/index.d.cts

@@ -0,0 +1,8 @@
+export { UseEvaluationOptions, useEvaluation } from './useEvaluation.cjs';
+export { UseContentOptions, useContent } from './useContent.cjs';
+export { useCroct } from './useCroct.cjs';
+import '@croct/plug/sdk/json';
+import '@croct/sdk/facade/evaluatorFacade';
+import '@croct/plug/slot';
+import '@croct/plug/plug';
+import '@croct/plug';

package/hooks/index.d.ts

@@ -1,3 +1,8 @@
-export * from './useEvaluation';
-export * from './useContent';
-export * from './useCroct';
+export { UseEvaluationOptions, useEvaluation } from './useEvaluation.js';
+export { UseContentOptions, useContent } from './useContent.js';
+export { useCroct } from './useCroct.js';
+import '@croct/plug/sdk/json';
+import '@croct/sdk/facade/evaluatorFacade';
+import '@croct/plug/slot';
+import '@croct/plug/plug';
+import '@croct/plug';

package/hooks/index.js

@@ -1,20 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./useEvaluation"), exports);
-__exportStar(require("./useContent"), exports);
-__exportStar(require("./useCroct"), exports);
-//# sourceMappingURL=index.js.map
+export * from "./useEvaluation.js";
+export * from "./useContent.js";
+export * from "./useCroct.js";

package/hooks/useContent.cjs

@@ -0,0 +1,92 @@
+"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_react = require("react");
+var import_content = require("@croct/content");
+var import_useLoader = require('./useLoader.cjs');
+var import_useCroct = require('./useCroct.cjs');
+var import_ssr_polyfills = require('../ssr-polyfills.cjs');
+var import_hash = require('../hash.cjs');
+function useCsrContent(id, options = {}) {
+  const {
+    cacheKey,
+    expiration,
+    fallback: fallbackContent,
+    initial: initialContent,
+    staleWhileLoading = false,
+    ...fetchOptions
+  } = options;
+  const preferredLocale = normalizePreferredLocale(fetchOptions.preferredLocale);
+  const defaultContent = (0, import_react.useMemo)(
+    () => (0, import_content.getSlotContent)(id, preferredLocale) ?? void 0,
+    [id, preferredLocale]
+  );
+  const fallback = fallbackContent === void 0 ? defaultContent : fallbackContent;
+  const [initial, setInitial] = (0, import_react.useState)(
+    () => initialContent === void 0 ? defaultContent : initialContent
+  );
+  const croct = (0, import_useCroct.useCroct)();
+  const result = (0, import_useLoader.useLoader)({
+    cacheKey: (0, import_hash.hash)(
+      `useContent:${cacheKey ?? ""}:${id}:${preferredLocale ?? ""}:${JSON.stringify(fetchOptions.attributes ?? {})}`
+    ),
+    loader: () => croct.fetch(id, {
+      ...fetchOptions,
+      preferredLocale,
+      fallback
+    }).then(({ content }) => content),
+    initial,
+    expiration
+  });
+  (0, import_react.useEffect)(
+    () => {
+      if (staleWhileLoading) {
+        setInitial((current) => {
+          if (current !== result) {
+            return result;
+          }
+          return current;
+        });
+      }
+    },
+    [result, staleWhileLoading]
+  );
+  return result;
+}
+function useSsrContent(slotId, { initial, preferredLocale } = {}) {
+  const resolvedInitialContent = initial === void 0 ? (0, import_content.getSlotContent)(slotId, normalizePreferredLocale(preferredLocale)) ?? void 0 : initial;
+  if (resolvedInitialContent === void 0) {
+    throw new Error(
+      "The initial content is required for server-side rendering (SSR). For help, see https://croct.help/sdk/react/missing-slot-content"
+    );
+  }
+  return resolvedInitialContent;
+}
+function normalizePreferredLocale(preferredLocale) {
+  return preferredLocale !== void 0 && preferredLocale !== "" ? preferredLocale : void 0;
+}
+const useContent = (0, import_ssr_polyfills.isSsr)() ? useSsrContent : useCsrContent;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useContent
+});

package/hooks/useContent.d.cts

@@ -0,0 +1,20 @@
+import { VersionedSlotMap, VersionedSlotId, SlotContent } from '@croct/plug/slot';
+import { JsonObject } from '@croct/plug/sdk/json';
+import { FetchOptions } from '@croct/plug/plug';
+
+type UseContentOptions<I, F> = FetchOptions<F> & {
+    initial?: I;
+    cacheKey?: string;
+    expiration?: number;
+    staleWhileLoading?: boolean;
+};
+type UseContentHook = {
+    <P extends JsonObject, I = P, F = P>(id: keyof VersionedSlotMap extends never ? string : never, options?: UseContentOptions<I, F>): P | I | F;
+    <S extends VersionedSlotId>(id: S, options?: UseContentOptions<never, never>): SlotContent<S>;
+    <I, S extends VersionedSlotId>(id: S, options?: UseContentOptions<I, never>): SlotContent<S> | I;
+    <F, S extends VersionedSlotId>(id: S, options?: UseContentOptions<never, F>): SlotContent<S> | F;
+    <I, F, S extends VersionedSlotId>(id: S, options?: UseContentOptions<I, F>): SlotContent<S> | I | F;
+};
+declare const useContent: UseContentHook;
+
+export { type UseContentOptions, useContent };

package/hooks/useContent.d.ts

@@ -1,8 +1,8 @@
-import { SlotContent, VersionedSlotId, VersionedSlotMap } from '@croct/plug/slot';
+import { VersionedSlotMap, VersionedSlotId, SlotContent } from '@croct/plug/slot';
 import { JsonObject } from '@croct/plug/sdk/json';
 import { FetchOptions } from '@croct/plug/plug';
-export type UseContentOptions<I, F> = FetchOptions & {
-    fallback?: F;
+
+type UseContentOptions<I, F> = FetchOptions<F> & {
     initial?: I;
     cacheKey?: string;
     expiration?: number;
@@ -15,5 +15,6 @@ type UseContentHook = {
     <F, S extends VersionedSlotId>(id: S, options?: UseContentOptions<never, F>): SlotContent<S> | F;
     <I, F, S extends VersionedSlotId>(id: S, options?: UseContentOptions<I, F>): SlotContent<S> | I | F;
 };
-export declare const useContent: UseContentHook;
-export {};
+declare const useContent: UseContentHook;
+
+export { type UseContentOptions, useContent };

package/hooks/useContent.js

@@ -1,45 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useContent = void 0;
-const react_1 = require("react");
-const useLoader_1 = require("./useLoader");
-const useCroct_1 = require("./useCroct");
-const ssr_polyfills_1 = require("../ssr-polyfills");
-const hash_1 = require("../hash");
+import { useEffect, useMemo, useState } from "react";
+import { getSlotContent } from "@croct/content";
+import { useLoader } from "./useLoader.js";
+import { useCroct } from "./useCroct.js";
+import { isSsr } from "../ssr-polyfills.js";
+import { hash } from "../hash.js";
 function useCsrContent(id, options = {}) {
-    var _a;
-    const { fallback, cacheKey, expiration, initial: initialContent, staleWhileLoading = false, ...fetchOptions } = options;
-    const [initial, setInitial] = (0, react_1.useState)(initialContent);
-    const { preferredLocale } = fetchOptions;
-    const croct = (0, useCroct_1.useCroct)();
-    const result = (0, useLoader_1.useLoader)({
-        cacheKey: (0, hash_1.hash)(`useContent:${cacheKey !== null && cacheKey !== void 0 ? cacheKey : ''}`
-            + `:${id}`
-            + `:${preferredLocale !== null && preferredLocale !== void 0 ? preferredLocale : ''}`
-            + `:${JSON.stringify((_a = fetchOptions.attributes) !== null && _a !== void 0 ? _a : {})}`),
-        loader: () => croct.fetch(id, fetchOptions).then(({ content }) => content),
-        initial: initial,
-        fallback: fallback,
-        expiration: expiration,
-    });
-    (0, react_1.useEffect)(() => {
-        if (staleWhileLoading) {
-            setInitial(current => {
-                if (current !== result) {
-                    return result;
-                }
-                return current;
-            });
-        }
-    }, [result, staleWhileLoading]);
-    return result;
+  const {
+    cacheKey,
+    expiration,
+    fallback: fallbackContent,
+    initial: initialContent,
+    staleWhileLoading = false,
+    ...fetchOptions
+  } = options;
+  const preferredLocale = normalizePreferredLocale(fetchOptions.preferredLocale);
+  const defaultContent = useMemo(
+    () => getSlotContent(id, preferredLocale) ?? void 0,
+    [id, preferredLocale]
+  );
+  const fallback = fallbackContent === void 0 ? defaultContent : fallbackContent;
+  const [initial, setInitial] = useState(
+    () => initialContent === void 0 ? defaultContent : initialContent
+  );
+  const croct = useCroct();
+  const result = useLoader({
+    cacheKey: hash(
+      `useContent:${cacheKey ?? ""}:${id}:${preferredLocale ?? ""}:${JSON.stringify(fetchOptions.attributes ?? {})}`
+    ),
+    loader: () => croct.fetch(id, {
+      ...fetchOptions,
+      preferredLocale,
+      fallback
+    }).then(({ content }) => content),
+    initial,
+    expiration
+  });
+  useEffect(
+    () => {
+      if (staleWhileLoading) {
+        setInitial((current) => {
+          if (current !== result) {
+            return result;
+          }
+          return current;
+        });
+      }
+    },
+    [result, staleWhileLoading]
+  );
+  return result;
 }
-function useSsrContent(_, { initial } = {}) {
-    if (initial === undefined) {
-        throw new Error('The initial content is required for server-side rendering (SSR). '
-            + 'For help, see https://croct.help/sdk/react/missing-slot-content');
-    }
-    return initial;
+function useSsrContent(slotId, { initial, preferredLocale } = {}) {
+  const resolvedInitialContent = initial === void 0 ? getSlotContent(slotId, normalizePreferredLocale(preferredLocale)) ?? void 0 : initial;
+  if (resolvedInitialContent === void 0) {
+    throw new Error(
+      "The initial content is required for server-side rendering (SSR). For help, see https://croct.help/sdk/react/missing-slot-content"
+    );
+  }
+  return resolvedInitialContent;
 }
-exports.useContent = (0, ssr_polyfills_1.isSsr)() ? useSsrContent : useCsrContent;
-//# sourceMappingURL=useContent.js.map
+function normalizePreferredLocale(preferredLocale) {
+  return preferredLocale !== void 0 && preferredLocale !== "" ? preferredLocale : void 0;
+}
+const useContent = isSsr() ? useSsrContent : useCsrContent;
+export {
+  useContent
+};

package/hooks/useCroct.cjs

@@ -0,0 +1,38 @@
+"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 useCroct_exports = {};
+__export(useCroct_exports, {
+  useCroct: () => useCroct
+});
+module.exports = __toCommonJS(useCroct_exports);
+var import_react = require("react");
+var import_CroctProvider = require('../CroctProvider.cjs');
+function useCroct() {
+  const context = (0, import_react.useContext)(import_CroctProvider.CroctContext);
+  if (context === null) {
+    throw new Error(
+      "useCroct() can only be used in the context of a <CroctProvider> component. For help, see https://croct.help/sdk/react/missing-provider"
+    );
+  }
+  return context.plug;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCroct
+});

package/hooks/useCroct.d.cts

@@ -0,0 +1,5 @@
+import { Plug } from '@croct/plug';
+
+declare function useCroct(): Plug;
+
+export { useCroct };

package/hooks/useCroct.d.ts

@@ -1,2 +1,5 @@
 import { Plug } from '@croct/plug';
-export declare function useCroct(): Plug;
+
+declare function useCroct(): Plug;
+
+export { useCroct };

package/hooks/useCroct.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useCroct = useCroct;
-const react_1 = require("react");
-const CroctProvider_1 = require("../CroctProvider");
+import { useContext } from "react";
+import { CroctContext } from "../CroctProvider.js";
 function useCroct() {
-    const context = (0, react_1.useContext)(CroctProvider_1.CroctContext);
-    if (context === null) {
-        throw new Error('useCroct() can only be used in the context of a <CroctProvider> component. '
-            + 'For help, see https://croct.help/sdk/react/missing-provider');
-    }
-    return context.plug;
+  const context = useContext(CroctContext);
+  if (context === null) {
+    throw new Error(
+      "useCroct() can only be used in the context of a <CroctProvider> component. For help, see https://croct.help/sdk/react/missing-provider"
+    );
+  }
+  return context.plug;
 }
-//# sourceMappingURL=useCroct.js.map
+export {
+  useCroct
+};