prosebook 0.0.1 → 0.2.0

package/dist/react/index.d.ts

@@ -0,0 +1,37 @@
+import { S as RichParam, b as RegisteredMessages, h as MessageShape, n as Copy, w as TagFn, x as RichKey, y as RegisteredLocale } from "../copy-DXnzXsJa.js";
+import { ReactNode } from "react";
+type M = RegisteredMessages;
+type L = RegisteredLocale;
+/** `Copy`, with `rich` returning a `ReactNode`. */
+export interface ReactCopy extends Omit<Copy<M, L>, 'rich'> {
+  rich<K extends RichKey<M>>(this: void, key: K, ...values: RichParam<M[K], ReactNode>): ReactNode;
+}
+type Tags = {
+  readonly [tag: string]: TagFn<ReactNode>;
+};
+export interface CopyProviderProps {
+  copy: Copy<M, L> | Copy;
+  /** Tag renderers every rich read under this provider gets, beside the copy's own. */
+  tags?: Tags;
+  children?: ReactNode;
+}
+export declare function CopyProvider({ copy, tags, children }: CopyProviderProps): import("react").JSX.Element;
+/** The catalog, in the current locale. Re-renders the component when the locale changes, or in dev the catalog. */
+export declare function useCopy(): ReactCopy;
+/** The current locale alone, for components that only format or switch. */
+export declare function useLocale(): L;
+type ValuesProp<S extends MessageShape> = {} extends S['args'] & { [T in S['tags']]: unknown; } ? {
+  values?: S['args'] & { [T in S['tags']]?: TagFn<ReactNode>; };
+} : {
+  values: RichParam<S, ReactNode>[0];
+};
+export type TextProps<K extends Extract<keyof M, string>> = {
+  id: K;
+} & ValuesProp<M[K]>;
+/**
+ * A message as an element: `<Text id="cart.items" values={{ count }} />`. Rich messages render their
+ * tags through the provider's renderers and any given in `values`.
+ */
+export declare function Text<K extends Extract<keyof M, string>>(props: TextProps<K>): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/react/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/react/index.tsx"],"mappings":";;KAYK,IAAI;KACJ,IAAI;;iBAGQ,kBAAkB,KAAK,KAAK,GAAG;EAC9C,KAAK,UAAU,QAAQ,IAAI,YAAY,KAAK,MAAM,QAAQ,UAAU,EAAE,IAAI,aAAa;;KAKpF;YAAmB,cAAc,MAAM;;iBAE3B;EACf,MAAM,KAAK,GAAG,KAAK;;EAEnB,OAAO;EACP,WAAW;;wBAGG,eAAe,MAAM,MAAM,YAAY,oCAAiB,IAAA;;wBAMxD,WAAW;;wBAaX,aAAa;KA+CxB,WAAW,UAAU,2BAA2B,eAAe,KAAK;EACnE,SAAS,eAAe,KAAK,aAAa,MAAM;;EAChD,QAAQ,UAAU,GAAG;;YAEf,UAAU,UAAU,cAAc;EAAgB,IAAI;IAAM,WAAW,EAAE;;;;;wBAMrE,KAAK,UAAU,cAAc,YAAY,OAAO,UAAU,qBAAE,IAAA"}

package/dist/react/index.js

@@ -0,0 +1,86 @@
+import { Fragment, createContext, isValidElement, use, useMemo, useSyncExternalStore } from "react";
+import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
+// src/react/index.tsx
+/**
+* `prosebook/react`: the catalog in components.
+*
+* `useCopy()` re-renders its component when the locale changes, and its `rich` returns a ready
+* `ReactNode`: elements are keyed and tag functions receive keyed children, so a sentence with a
+* link inside it is one catalog entry and one call, with no wrapper to remember.
+*/
+const CopyContext = createContext(null);
+function CopyProvider({ copy, tags, children }) {
+	const value = useMemo(() => ({
+		copy,
+		tags: {
+			...copy.tags,
+			...tags
+		}
+	}), [copy, tags]);
+	return /* @__PURE__ */ jsx(CopyContext, {
+		value,
+		children
+	});
+}
+/** The catalog, in the current locale. Re-renders the component when the locale changes, or in dev the catalog. */
+function useCopy() {
+	const context = use(CopyContext);
+	if (context === null) throw new Error("prosebook: useCopy() needs a <CopyProvider> above it");
+	const { copy, tags } = context;
+	const version = useSyncExternalStore(copy.subscribe, () => copy.version, () => copy.version);
+	return useMemo(() => readerFor(copy, tags, version), [
+		copy,
+		tags,
+		version
+	]);
+}
+/** The current locale alone, for components that only format or switch. */
+function useLocale() {
+	const context = use(CopyContext);
+	if (context === null) throw new Error("prosebook: useLocale() needs a <CopyProvider> above it");
+	return useSyncExternalStore(context.copy.subscribe, () => context.copy.locale, () => context.copy.locale);
+}
+function readerFor(copy, tags, version) {
+	return {
+		locale: copy.locale,
+		version,
+		locales: copy.locales,
+		source: copy.source,
+		tags: copy.tags,
+		ready: copy.ready,
+		t: copy.t,
+		has: copy.has,
+		setLocale: copy.setLocale,
+		subscribe: copy.subscribe,
+		number: copy.number,
+		date: copy.date,
+		list: copy.list,
+		relative: copy.relative,
+		rich(key, ...values) {
+			const given = values[0] ?? {};
+			const merged = {
+				...tags,
+				...given
+			};
+			for (const [name, value] of Object.entries(merged)) if (typeof value === "function") merged[name] = (chunks) => value(keyed(chunks));
+			return /* @__PURE__ */ jsx(Fragment$1, { children: keyed(copy.rich(key, merged)) });
+		}
+	};
+}
+/** Text joined where it can be, and each element under its own key, so React never warns about a list. */
+function keyed(parts) {
+	if (parts.every((p) => typeof p === "string")) return [parts.join("")];
+	return parts.map((p, i) => isValidElement(p) || typeof p === "object" ? /* @__PURE__ */ jsx(Fragment, { children: p }, i) : p);
+}
+/**
+* A message as an element: `<Text id="cart.items" values={{ count }} />`. Rich messages render their
+* tags through the provider's renderers and any given in `values`.
+*/
+function Text(props) {
+	const copy = useCopy();
+	const values = props.values;
+	return /* @__PURE__ */ jsx(Fragment$1, { children: copy.rich(props.id, values) });
+}
+export { CopyProvider, Text, useCopy, useLocale };
+
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/react/index.tsx"],"sourcesContent":["/**\n * `prosebook/react`: the catalog in components.\n *\n * `useCopy()` re-renders its component when the locale changes, and its `rich` returns a ready\n * `ReactNode`: elements are keyed and tag functions receive keyed children, so a sentence with a\n * link inside it is one catalog entry and one call, with no wrapper to remember.\n */\nimport { createContext, Fragment, isValidElement, use, useMemo, useSyncExternalStore, type ReactNode } from 'react';\n\nimport type { Copy } from '#src/runtime/copy.ts';\nimport type { MessageShape, RegisteredLocale, RegisteredMessages, RichKey, RichParam, TagFn } from '#src/runtime/types.ts';\n\ntype M = RegisteredMessages;\ntype L = RegisteredLocale;\n\n/** `Copy`, with `rich` returning a `ReactNode`. */\nexport interface ReactCopy extends Omit<Copy<M, L>, 'rich'> {\n  rich<K extends RichKey<M>>(this: void, key: K, ...values: RichParam<M[K], ReactNode>): ReactNode;\n}\n\nconst CopyContext = createContext<{ copy: Copy<M, L>; tags: Tags } | null>(null);\n\ntype Tags = { readonly [tag: string]: TagFn<ReactNode> };\n\nexport interface CopyProviderProps {\n  copy: Copy<M, L> | Copy;\n  /** Tag renderers every rich read under this provider gets, beside the copy's own. */\n  tags?: Tags;\n  children?: ReactNode;\n}\n\nexport function CopyProvider({ copy, tags, children }: CopyProviderProps) {\n  const value = useMemo(() => ({ copy: copy as Copy<M, L>, tags: { ...(copy.tags as unknown as Tags), ...tags } }), [copy, tags]);\n  return <CopyContext value={value}>{children}</CopyContext>;\n}\n\n/** The catalog, in the current locale. Re-renders the component when the locale changes, or in dev the catalog. */\nexport function useCopy(): ReactCopy {\n  const context = use(CopyContext);\n  if (context === null) throw new Error('prosebook: useCopy() needs a <CopyProvider> above it');\n  const { copy, tags } = context;\n  const version = useSyncExternalStore(\n    copy.subscribe,\n    () => copy.version,\n    () => copy.version,\n  );\n  return useMemo(() => readerFor(copy, tags, version), [copy, tags, version]);\n}\n\n/** The current locale alone, for components that only format or switch. */\nexport function useLocale(): L {\n  const context = use(CopyContext);\n  if (context === null) throw new Error('prosebook: useLocale() needs a <CopyProvider> above it');\n  return useSyncExternalStore(\n    context.copy.subscribe,\n    () => context.copy.locale,\n    () => context.copy.locale,\n  );\n}\n\n// Takes the version only so the reader is rebuilt, and its identity changes, when what it reads does.\nfunction readerFor(copy: Copy<M, L>, tags: Tags, version: number): ReactCopy {\n  return {\n    locale: copy.locale,\n    version,\n    locales: copy.locales,\n    source: copy.source,\n    tags: copy.tags,\n    ready: copy.ready,\n    t: copy.t,\n    has: copy.has,\n    setLocale: copy.setLocale,\n    subscribe: copy.subscribe,\n    number: copy.number,\n    date: copy.date,\n    list: copy.list,\n    relative: copy.relative,\n    rich(key, ...values) {\n      const given = (values[0] ?? {}) as Record<string, unknown>;\n      const merged: Record<string, unknown> = { ...tags, ...given };\n      for (const [name, value] of Object.entries(merged))\n        if (typeof value === 'function') merged[name] = (chunks: unknown[]) => (value as TagFn<ReactNode>)(keyed(chunks));\n\n      return <>{keyed(copy.rich(key as never, merged as never))}</>;\n    },\n  };\n}\n\n/** Text joined where it can be, and each element under its own key, so React never warns about a list. */\nfunction keyed(parts: unknown[]): (string | ReactNode)[] {\n  if (parts.every((p) => typeof p === 'string')) return [parts.join('')];\n  return parts.map((p, i) =>\n    // oxlint-disable-next-line react/no-array-index-key -- the parts of one message never reorder, so positions are stable keys\n    isValidElement(p) || typeof p === 'object' ? <Fragment key={i}>{p as ReactNode}</Fragment> : (p as ReactNode),\n  );\n}\n\ntype ValuesProp<S extends MessageShape> = {} extends S['args'] & { [T in S['tags']]: unknown }\n  ? { values?: S['args'] & { [T in S['tags']]?: TagFn<ReactNode> } }\n  : { values: RichParam<S, ReactNode>[0] };\n\nexport type TextProps<K extends Extract<keyof M, string>> = { id: K } & ValuesProp<M[K]>;\n\n/**\n * A message as an element: `<Text id=\"cart.items\" values={{ count }} />`. Rich messages render their\n * tags through the provider's renderers and any given in `values`.\n */\nexport function Text<K extends Extract<keyof M, string>>(props: TextProps<K>) {\n  const copy = useCopy();\n  const values = (props as { values?: object }).values;\n  return <>{copy.rich(props.id as RichKey<M>, values)}</>;\n}\n"],"mappings":";;;;;;;;;;AAoBA,MAAM,cAAc,cAAuD,IAAI;AAW/E,SAAgB,aAAa,EAAE,MAAM,MAAM,YAA+B;CACxE,MAAM,QAAQ,eAAe;EAAQ;EAAoB,MAAM;GAAE,GAAI,KAAK;GAA0B,GAAG;EAAK;CAAE,IAAI,CAAC,MAAM,IAAI,CAAC;CAC9H,OAAO,oBAAC,aAAD;EAAoB;EAAQ;CAAsB,CAAA;AAC3D;;AAGA,SAAgB,UAAqB;CACnC,MAAM,UAAU,IAAI,WAAW;CAC/B,IAAI,YAAY,MAAM,MAAM,IAAI,MAAM,sDAAsD;CAC5F,MAAM,EAAE,MAAM,SAAS;CACvB,MAAM,UAAU,qBACd,KAAK,iBACC,KAAK,eACL,KAAK,OACb;CACA,OAAO,cAAc,UAAU,MAAM,MAAM,OAAO,GAAG;EAAC;EAAM;EAAM;CAAO,CAAC;AAC5E;;AAGA,SAAgB,YAAe;CAC7B,MAAM,UAAU,IAAI,WAAW;CAC/B,IAAI,YAAY,MAAM,MAAM,IAAI,MAAM,wDAAwD;CAC9F,OAAO,qBACL,QAAQ,KAAK,iBACP,QAAQ,KAAK,cACb,QAAQ,KAAK,MACrB;AACF;AAGA,SAAS,UAAU,MAAkB,MAAY,SAA4B;CAC3E,OAAO;EACL,QAAQ,KAAK;EACb;EACA,SAAS,KAAK;EACd,QAAQ,KAAK;EACb,MAAM,KAAK;EACX,OAAO,KAAK;EACZ,GAAG,KAAK;EACR,KAAK,KAAK;EACV,WAAW,KAAK;EAChB,WAAW,KAAK;EAChB,QAAQ,KAAK;EACb,MAAM,KAAK;EACX,MAAM,KAAK;EACX,UAAU,KAAK;EACf,KAAK,KAAK,GAAG,QAAQ;GACnB,MAAM,QAAS,OAAO,MAAM,CAAC;GAC7B,MAAM,SAAkC;IAAE,GAAG;IAAM,GAAG;GAAM;GAC5D,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,MAAM,GAC/C,IAAI,OAAO,UAAU,YAAY,OAAO,SAAS,WAAuB,MAA2B,MAAM,MAAM,CAAC;GAElH,OAAO,oBAAA,YAAA,EAAA,UAAG,MAAM,KAAK,KAAK,KAAc,MAAe,CAAC,EAAI,CAAA;EAC9D;CACF;AACF;;AAGA,SAAS,MAAM,OAA0C;CACvD,IAAI,MAAM,OAAO,MAAM,OAAO,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,KAAK,EAAE,CAAC;CACrE,OAAO,MAAM,KAAK,GAAG,MAEnB,eAAe,CAAC,KAAK,OAAO,MAAM,WAAW,oBAAC,UAAD,EAAA,UAAmB,EAAyB,GAA7B,CAA6B,IAAK,CAChG;AACF;;;;;AAYA,SAAgB,KAAyC,OAAqB;CAC5E,MAAM,OAAO,QAAQ;CACrB,MAAM,SAAU,MAA8B;CAC9C,OAAO,oBAAA,YAAA,EAAA,UAAG,KAAK,KAAK,MAAM,IAAkB,MAAM,EAAI,CAAA;AACxD"}