@redeemid/emdash 0.0.9 → 0.0.10

package/src/preferences.ts

@@ -0,0 +1,298 @@
+/**
+ * Member preferences: customer metafields members may see or change, such as
+ * the topics they follow. Shopify defines each field (Settings → Custom data
+ * → Customers); `preferences` in the config picks which ones members get, and
+ * whether they may change them. Answers live on the Shopify customer, where
+ * Flow, segments and email can use them. The site keeps no copy.
+ *
+ * Reading and saving use the Admin API app (the staff tools' client ID), and
+ * always on the signed-in member's own customer. Preferences never open
+ * content: access still comes only from tags.
+ */
+
+import { admin, adminConfigured, AdminError } from "./admin-api.js";
+import type { PreferenceConfig, RedeemIDConfig } from "./config.js";
+import type { MemberRecord } from "./storage.js";
+
+/** Metafield types members can use, and the value each takes. */
+export const PREFERENCE_TYPES = [
+	"single_line_text_field",
+	"multi_line_text_field",
+	"list.single_line_text_field",
+	"boolean",
+	"number_integer",
+	"number_decimal",
+	"date",
+] as const;
+export type PreferenceType = (typeof PREFERENCE_TYPES)[number];
+export type PreferenceValue = string | string[] | boolean | number | null;
+
+export interface PreferenceField {
+	/** "namespace.key" */
+	key: string;
+	name: string;
+	description: string | null;
+	type: PreferenceType;
+	choices: string[] | null;
+	/** Length for text, value for numbers and dates. */
+	min: string | null;
+	max: string | null;
+	editable: boolean;
+	value: PreferenceValue;
+}
+
+export type Refusal = "unknown_field" | "read_only" | "invalid_type" | "invalid_choice" | "invalid_length" | "invalid_range";
+
+export class PreferenceError extends Error {
+	constructor(
+		message: string,
+		readonly fields: Record<string, Refusal> = {},
+	) {
+		super(message);
+	}
+}
+
+/** Saves allowed per member per minute. */
+export const SAVES_PER_MINUTE = 10;
+const DEFINITIONS_TTL_MS = 5 * 60 * 1000;
+/** RedeemID reads membership dates from this namespace, so members never get it. */
+const RESERVED_NAMESPACE = "membership";
+
+type Definition = Omit<PreferenceField, "editable" | "value">;
+let cache: { at: number; shop: string; defs: Definition[] } | null = null;
+
+export function resetPreferenceCache(): void {
+	cache = null;
+}
+
+/** Can preferences run at all? */
+export function preferencesConfigured(config: RedeemIDConfig | null): boolean {
+	return Boolean(config?.preferences?.length && adminConfigured());
+}
+
+function wanted(config: RedeemIDConfig): PreferenceConfig[] {
+	return (config.preferences ?? []).filter((p) => /^[\w-]+\.[\w-]+$/.test(p.key) && !p.key.startsWith(`${RESERVED_NAMESPACE}.`));
+}
+
+/** The customer metafield definitions Shopify has for the configured keys, cached for five minutes. */
+export async function definitions(config: RedeemIDConfig, fetcher: typeof fetch = fetch): Promise<Definition[]> {
+	const shop = config.shop ?? "";
+	if (cache && cache.shop === shop && Date.now() - cache.at < DEFINITIONS_TTL_MS) return cache.defs;
+	type Node = { namespace: string; key: string; name: string; description: string | null; type: { name: string }; validations: Array<{ name: string; value: string | null }> };
+	const data = await admin<{ metafieldDefinitions: { nodes: Node[] } }>(
+		config,
+		`query RedeemIDPreferenceDefinitions { metafieldDefinitions(ownerType: CUSTOMER, first: 250) { nodes { namespace key name description type { name } validations { name value } } } }`,
+		{},
+		fetcher,
+	);
+	const defs = data.metafieldDefinitions.nodes
+		.filter((n) => (PREFERENCE_TYPES as readonly string[]).includes(n.type.name))
+		.map((n) => {
+			const v = (name: string) => n.validations.find((x) => x.name === name)?.value ?? null;
+			let choices: string[] | null = null;
+			try {
+				const raw = v("choices");
+				const parsed = raw ? (JSON.parse(raw) as unknown) : null;
+				if (Array.isArray(parsed)) choices = parsed.map(String);
+			} catch {
+				choices = null;
+			}
+			return {
+				key: `${n.namespace}.${n.key}`,
+				name: n.name,
+				description: n.description || null,
+				type: n.type.name as PreferenceType,
+				choices,
+				// Length for text types, value for numbers and dates.
+				min: v("min") || null,
+				max: v("max") || null,
+			};
+		});
+	cache = { at: Date.now(), shop, defs };
+	return defs;
+}
+
+/** Turn a stored metafield value into what members see. */
+export function decode(type: PreferenceType, raw: string | null | undefined): PreferenceValue {
+	if (raw == null || raw === "") return type.startsWith("list.") ? [] : null;
+	switch (type) {
+		case "list.single_line_text_field":
+			try {
+				const v = JSON.parse(raw) as unknown;
+				return Array.isArray(v) ? v.map(String) : [];
+			} catch {
+				return [];
+			}
+		case "boolean":
+			return raw === "true";
+		case "number_integer":
+			return Number.parseInt(raw, 10);
+		default:
+			return raw;
+	}
+}
+
+const isEmpty = (v: unknown) => v === null || v === undefined || v === "" || (Array.isArray(v) && v.length === 0);
+
+/**
+ * Check one value against its definition. Returns the metafield value to
+ * save, null to clear the field, or a refusal.
+ */
+export function encode(def: Definition, input: unknown): { value: string | null } | { refused: Refusal } {
+	if (isEmpty(input)) return { value: null };
+	const len = (s: string) => {
+		if (def.min !== null && s.length < Number(def.min)) return false;
+		if (def.max !== null && s.length > Number(def.max)) return false;
+		return true;
+	};
+	const choice = (s: string) => !def.choices || def.choices.includes(s);
+	switch (def.type) {
+		case "single_line_text_field":
+		case "multi_line_text_field": {
+			if (typeof input !== "string") return { refused: "invalid_type" };
+			const s = def.type === "single_line_text_field" ? input.trim() : input;
+			if (def.type === "single_line_text_field" && /[\r\n]/.test(s)) return { refused: "invalid_type" };
+			if (!choice(s)) return { refused: "invalid_choice" };
+			if (!len(s)) return { refused: "invalid_length" };
+			return { value: s };
+		}
+		case "list.single_line_text_field": {
+			const list = typeof input === "string" ? [input] : input;
+			if (!Array.isArray(list) || list.some((x) => typeof x !== "string")) return { refused: "invalid_type" };
+			const items = [...new Set((list as string[]).map((x) => x.trim()).filter(Boolean))];
+			if (items.some((x) => /[\r\n]/.test(x))) return { refused: "invalid_type" };
+			if (!items.every(choice)) return { refused: "invalid_choice" };
+			if (!items.every(len)) return { refused: "invalid_length" };
+			return { value: items.length ? JSON.stringify(items) : null };
+		}
+		case "boolean": {
+			const b = input === true || input === "true" || input === "on" ? true : input === false || input === "false" ? false : null;
+			if (b === null) return { refused: "invalid_type" };
+			return { value: String(b) };
+		}
+		case "number_integer":
+		case "number_decimal": {
+			const s = typeof input === "number" ? String(input) : typeof input === "string" ? input.trim() : "";
+			const ok = def.type === "number_integer" ? /^-?\d+$/.test(s) : /^-?\d+(\.\d+)?$/.test(s);
+			if (!ok) return { refused: "invalid_type" };
+			const n = Number(s);
+			if ((def.min !== null && n < Number(def.min)) || (def.max !== null && n > Number(def.max))) return { refused: "invalid_range" };
+			return { value: s };
+		}
+		case "date": {
+			const s = typeof input === "string" ? input.trim() : "";
+			if (!/^\d{4}-\d{2}-\d{2}$/.test(s) || Number.isNaN(Date.parse(`${s}T00:00:00Z`))) return { refused: "invalid_type" };
+			if ((def.min !== null && s < def.min.slice(0, 10)) || (def.max !== null && s > def.max.slice(0, 10))) return { refused: "invalid_range" };
+			return { value: s };
+		}
+	}
+}
+
+/** The fields members can use, in config order, with their access. Without values. */
+export async function preferenceFields(config: RedeemIDConfig, fetcher: typeof fetch = fetch): Promise<Array<Omit<PreferenceField, "value">>> {
+	const defs = await definitions(config, fetcher);
+	return wanted(config).flatMap((p) => {
+		const def = defs.find((d) => d.key === p.key);
+		return def ? [{ ...def, editable: p.access !== "view" }] : [];
+	});
+}
+
+const gid = (id: string) => `gid://shopify/Customer/${id}`;
+
+/** The member's fields with their current values, read from Shopify. */
+export async function readPreferences(config: RedeemIDConfig, customerId: string, fetcher: typeof fetch = fetch): Promise<PreferenceField[]> {
+	const fields = await preferenceFields(config, fetcher);
+	if (fields.length === 0) return [];
+	type Node = { namespace: string; key: string; value: string };
+	const data = await admin<{ customer: { metafields: { nodes: Node[] } } | null }>(
+		config,
+		`query RedeemIDPreferences($id: ID!, $keys: [String!]) { customer(id: $id) { metafields(first: 100, keys: $keys) { nodes { namespace key value } } } }`,
+		{ id: gid(customerId), keys: fields.map((f) => f.key) },
+		fetcher,
+	);
+	if (!data.customer) throw new AdminError("Shopify has no such customer.");
+	const values = new Map(data.customer.metafields.nodes.map((n) => [`${n.namespace}.${n.key}`, n.value]));
+	return fields.map((f) => ({ ...f, value: decode(f.type, values.get(f.key)) }));
+}
+
+/** Room for one more save this minute? Records it when there is. */
+export function allowSave(member: Pick<MemberRecord, "prefSaves">, now = Date.now()): number[] | null {
+	const recent = (member.prefSaves ?? []).filter((t) => now - t < 60_000);
+	if (recent.length >= SAVES_PER_MINUTE) return null;
+	return [...recent, now];
+}
+
+/**
+ * Save some of the member's fields to their Shopify customer, then read them
+ * back. Every value is checked first; one refusal saves nothing. Keys left
+ * out are left alone; an empty value clears the field.
+ */
+export async function savePreferences(
+	config: RedeemIDConfig,
+	customerId: string,
+	values: Record<string, unknown>,
+	fetcher: typeof fetch = fetch,
+): Promise<{ fields: PreferenceField[]; changed: string[] }> {
+	const fields = await preferenceFields(config, fetcher);
+	const refused: Record<string, Refusal> = {};
+	const set: Array<{ namespace: string; key: string; type: string; value: string }> = [];
+	const clear: Array<{ namespace: string; key: string }> = [];
+	for (const [key, input] of Object.entries(values)) {
+		const f = fields.find((x) => x.key === key);
+		if (!f) {
+			refused[key] = "unknown_field";
+			continue;
+		}
+		if (!f.editable) {
+			refused[key] = "read_only";
+			continue;
+		}
+		const out = encode(f, input);
+		if ("refused" in out) {
+			refused[key] = out.refused;
+			continue;
+		}
+		const [namespace = "", k = ""] = key.split(".");
+		if (out.value === null) clear.push({ namespace, key: k });
+		else set.push({ namespace, key: k, type: f.type, value: out.value });
+	}
+	if (Object.keys(refused).length) throw new PreferenceError("Some answers weren't saved.", refused);
+
+	const ownerId = gid(customerId);
+	if (set.length) {
+		const data = await admin<{ metafieldsSet: { userErrors: Array<{ field?: string[] | null; message: string }> } }>(
+			config,
+			`mutation RedeemIDSavePreferences($metafields: [MetafieldsSetInput!]!) { metafieldsSet(metafields: $metafields) { userErrors { field message } } }`,
+			{ metafields: set.map((m) => ({ ownerId, ...m })) },
+			fetcher,
+		);
+		const err = data.metafieldsSet.userErrors[0];
+		if (err) throw new AdminError(err.message);
+	}
+	if (clear.length) {
+		const data = await admin<{ metafieldsDelete: { userErrors: Array<{ message: string }> } }>(
+			config,
+			`mutation RedeemIDClearPreferences($metafields: [MetafieldIdentifierInput!]!) { metafieldsDelete(metafields: $metafields) { userErrors { field message } } }`,
+			{ metafields: clear.map((m) => ({ ownerId, ...m })) },
+			fetcher,
+		);
+		const err = data.metafieldsDelete.userErrors[0];
+		if (err) throw new AdminError(err.message);
+	}
+	const changed = [...set, ...clear].map((m) => `${m.namespace}.${m.key}`);
+	return { fields: await readPreferences(config, customerId, fetcher), changed };
+}
+
+/** Read a posted form into values: `pref:<key>` fields, with `present:<key>` marking checkboxes and lists that may be empty. */
+export function formValues(form: FormData, fields: Array<Pick<PreferenceField, "key" | "type" | "editable">>): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const f of fields) {
+		if (!f.editable || !form.has(`present:${f.key}`)) continue;
+		const all = form.getAll(`pref:${f.key}`).map(String);
+		// A list without choices comes from a textarea: one answer per line.
+		if (f.type === "list.single_line_text_field") out[f.key] = all.flatMap((v) => v.split(/\r?\n/));
+		else if (f.type === "boolean") out[f.key] = all.includes("true");
+		else out[f.key] = all[0] ?? "";
+	}
+	return out;
+}

package/src/routes/preferences.ts

@@ -0,0 +1,82 @@
+/**
+ * /_emdash/api/auth/redeemid/preferences: the signed-in member's preferences.
+ *
+ * GET answers JSON: { fields } with values, for the member's own customer.
+ * POST takes JSON { values: { "namespace.key": value } } and answers JSON,
+ * or a form (from <Preferences>) and goes back to `return` with the notice
+ * preferences_saved, preferences_refused or preferences_unavailable.
+ * The customer always comes from the session, never from the request.
+ * Refused JSON saves answer 400 with { fields: { key: reason } }; more than
+ * 10 saves a minute answer 429.
+ */
+
+import type { APIRoute } from "astro";
+
+import { safeReturn, signInUrl } from "../access.js";
+import { readConfig } from "../config.js";
+import { emit } from "../events.js";
+import { allowSave, formValues, PreferenceError, preferenceFields, preferencesConfigured, readPreferences, savePreferences } from "../preferences.js";
+import { memberForUser, stores } from "../storage.js";
+import { fail } from "./shared.js";
+
+export const prerender = false;
+
+const json = (status: number, body: unknown) =>
+	new Response(JSON.stringify(body), { status, headers: { "Content-Type": "application/json", "Cache-Control": "private, no-store" } });
+
+async function context(locals: unknown, session: { get(k: string): Promise<unknown> } | undefined) {
+	const emdash = (locals as { emdash?: { config?: unknown; db?: unknown } }).emdash;
+	const config = readConfig(emdash?.config);
+	if (!config || !preferencesConfigured(config) || !emdash?.db) return { error: "unavailable" as const };
+	const user = (await session?.get("user")) as { id?: string } | undefined;
+	if (!user?.id) return { error: "sign_in" as const, config };
+	const s = stores(emdash.db);
+	const member = await memberForUser(s, user.id);
+	if (!member) return { error: "sign_in" as const, config };
+	if (member.status === "disabled") return { error: "disabled" as const, config };
+	return { config, s, member };
+}
+
+export const GET: APIRoute = async ({ locals, session }) => {
+	const c = await context(locals, session);
+	if ("error" in c) return json(c.error === "unavailable" ? 404 : 401, { error: c.error });
+	try {
+		return json(200, { fields: await readPreferences(c.config, c.member.customerId) });
+	} catch (e) {
+		console.error("[redeemid] preferences not read:", (e as Error).message);
+		return json(502, { error: "unavailable" });
+	}
+};
+
+export const POST: APIRoute = async ({ request, locals, session, redirect }) => {
+	const isJson = (request.headers.get("content-type") ?? "").includes("application/json");
+	const form = isJson ? null : await request.formData().catch(() => null);
+	const returnTo = safeReturn(String(form?.get("return") ?? "/"));
+	const c = await context(locals, session);
+	if ("error" in c) {
+		if (isJson) return json(c.error === "unavailable" ? 404 : 401, { error: c.error });
+		return c.error === "sign_in" ? redirect(signInUrl(returnTo)) : fail(redirect, returnTo, "preferences_unavailable");
+	}
+
+	const slots = allowSave(c.member);
+	if (!slots) return isJson ? json(429, { error: "too_many_saves" }) : fail(redirect, returnTo, "preferences_unavailable");
+
+	let values: Record<string, unknown>;
+	try {
+		if (isJson) {
+			const body = (await request.json()) as { values?: unknown };
+			values = body.values && typeof body.values === "object" && !Array.isArray(body.values) ? (body.values as Record<string, unknown>) : {};
+		} else {
+			values = formValues(form ?? new FormData(), await preferenceFields(c.config));
+		}
+		await c.s.members.put(c.member.customerId, { ...c.member, prefSaves: slots });
+		const { fields, changed } = await savePreferences(c.config, c.member.customerId, values);
+		// Field names only, never the answers.
+		if (changed.length) await emit(c.config, "preferences.saved", { customerId: c.member.customerId, fields: changed });
+		return isJson ? json(200, { fields }) : fail(redirect, returnTo, "preferences_saved");
+	} catch (e) {
+		if (e instanceof PreferenceError) return isJson ? json(400, { error: "refused", fields: e.fields }) : fail(redirect, returnTo, "preferences_refused");
+		console.error("[redeemid] preferences not saved:", (e as Error).message);
+		return isJson ? json(502, { error: "unavailable" }) : fail(redirect, returnTo, "preferences_unavailable");
+	}
+};

package/src/storage.ts

@@ -37,6 +37,8 @@ export interface MemberRecord {
 	linkedAt?: string | null;
 	/** Tags Shopify has removed, with when each was held (newest last, at most 50). */
 	pastTags?: PastTag[];
+	/** When the member last saved preferences (ms), newest last, at most 10: the rate limit. */
+	prefSaves?: number[];
 }
 
 /** A tag the customer held from `from` (when known) until `to`. */

package/src/text.ts

@@ -0,0 +1,174 @@
+/**
+ * Replacement text: give any string members and visitors see new words, one
+ * string at a time. Config `text` maps a string's original English to its
+ * replacement:
+ *
+ *   text: {
+ *     "Sign in": "Log in",
+ *     "This is for {level} members.": "{level} members only.",
+ *   }
+ *
+ * Only the strings named change: there is no find-and-replace across
+ * strings, so nothing changes that nobody looked at. STRINGS lists every
+ * original. Some have placeholders such as `{level}`, filled in when the
+ * text shows; a replacement may use its original's placeholders, in any
+ * order or not at all, but no others. A replacement that breaks this, or
+ * names a string RedeemID doesn't show, is ignored (the original shows) and
+ * listed on the Status page. Text is plain: HTML in a replacement shows as
+ * typed. Explicit component props (`label`, `title`, Notices `messages`) win
+ * over `text`.
+ */
+
+import type { RedeemIDConfig } from "./config.js";
+
+/** Every string RedeemID shows members and visitors, by where it shows. */
+export const STRINGS = {
+	account: ["Signed in", "Account", "Sign out", "Sign in"],
+	badge: ["Free", "Signed in", " (locked)"],
+	cart: [
+		"Cart",
+		"Your cart is empty.",
+		"Your cart isn't available right now. Try again in a few minutes.",
+		"{price} each · {total}",
+		"Quantity",
+		"Update",
+		"Remove",
+		"Discount code",
+		"Apply",
+		"{code} doesn't apply to this cart.",
+		"Subtotal",
+		"Total",
+		"Taxes and shipping are worked out at checkout.",
+		"Checkout",
+	],
+	collection: ["From {price}", "Sold out"],
+	contribution: ["Give", "Another amount ({currency})", "Quantity ({price} each)"],
+	meter: ["This is your last free read this week.", "This is your last free read this month.", "You have 1 free read left this week.", "You have 1 free read left this month.", "You have {count} free reads left this week.", "You have {count} free reads left this month."],
+	wall: [
+		"Become a member",
+		"This is for members. {signIn} to read on.",
+		"Sign in",
+		"Not a member yet? {join}.",
+		"You've used your free reads this week.",
+		"You've used your free reads this month.",
+		"This opens for you on {date}.",
+		"This opens for you after you've been a member a little longer.",
+		"This is for {level} members.",
+		"Your membership doesn't include this yet.",
+		"Your account is turned off. Contact the store for help.",
+		"This is for members.",
+	],
+	member: [
+		"Your membership",
+		"Your account is turned off. Contact the store for help.",
+		"since {date}",
+		"You don't have a membership yet.",
+		"Become a member",
+		"Includes: {features}",
+		"Before",
+		"{from} to {to}",
+		"until {to}",
+		"Free reads this week: {used} of {limit} used.",
+		"Free reads this month: {used} of {limit} used.",
+		"Orders and details",
+		"Refresh membership",
+		"Sign out",
+		"Just bought a plan? It can take a minute to show here. Refresh membership checks again.",
+		"{signIn} to see your membership.",
+		"Sign in",
+	],
+	notices: [
+		"Sign-in isn't set up on this site yet.",
+		"Sign-in isn't available right now. Try again in a few minutes.",
+		"That sign-in took too long. Try again.",
+		"This account can't sign in here. Use a different email.",
+		"This site isn't ready for sign-in yet.",
+		"Your account needs an email address to sign in.",
+		"Sign-in didn't finish. Try again.",
+		"That plan isn't available right now.",
+		"Checkout didn't open. Try again.",
+		"Your cart is empty.",
+		"Added to your cart.",
+		"Your cart is updated.",
+		"Discount applied.",
+		"That discount code doesn't apply to this cart.",
+		"Your membership is up to date.",
+		"Your preferences are saved.",
+		"Some answers weren't saved. Check them and try again.",
+		"Your preferences can't be saved right now. Try again in a few minutes.",
+		"Your account page isn't available right now. Try again in a few minutes.",
+	],
+	plan: ["Join", "You're on this plan.", "Not available right now."],
+	preferences: ["Your preferences", "Save preferences", "Your preferences can't be loaded right now. Try again in a few minutes.", "Not set", "Yes", "No", "One per line."],
+	product: ["Add to cart", "Buy now", "Option", "{option} ({price})", "{option} ({price}) sold out", "Quantity", "Sold out."],
+	files: ["File not available", "Sign in to download this file.", "Sign in", "Your membership doesn't include this file."],
+} as const;
+
+const ALL = new Set<string>(Object.values(STRINGS).flat());
+
+const PLACEHOLDER = /\{(\w+)\}/g;
+
+export function placeholders(s: string): string[] {
+	return [...s.matchAll(PLACEHOLDER)].map((m) => m[1] as string);
+}
+
+/** Why a replacement can't be used, or null when it can. */
+export function textProblem(original: string, replacement: unknown): string | null {
+	if (!ALL.has(original)) return "RedeemID doesn't show this string";
+	if (typeof replacement !== "string") return "The replacement isn't text";
+	const allowed = new Set(placeholders(original));
+	const extra = placeholders(replacement).filter((p) => !allowed.has(p));
+	if (extra.length) return `Uses ${[...new Set(extra)].map((p) => `{${p}}`).join(", ")}, which the original doesn't have`;
+	return null;
+}
+
+const checked = new WeakMap<object, { ok: Map<string, string>; problems: Array<{ original: string; problem: string }> }>();
+
+function table(config: RedeemIDConfig | null | undefined) {
+	const map = config?.text;
+	if (!map || typeof map !== "object") return null;
+	let t = checked.get(map);
+	if (!t) {
+		t = { ok: new Map(), problems: [] };
+		for (const [original, replacement] of Object.entries(map)) {
+			const problem = textProblem(original, replacement);
+			if (problem) t.problems.push({ original, problem });
+			else t.ok.set(original, replacement as string);
+		}
+		if (t.problems.length) console.warn(`[redeemid] ${t.problems.length} text replacement(s) ignored; see Status.`);
+		checked.set(map, t);
+	}
+	return t;
+}
+
+/** Replacements that are ignored, and why. */
+export function textProblems(config: RedeemIDConfig | null | undefined): Array<{ original: string; problem: string }> {
+	return table(config)?.problems ?? [];
+}
+
+/** The text for one string, with plain placeholders filled in. */
+export function text(config: RedeemIDConfig | null | undefined, original: string, vars: Record<string, string | number> = {}): string {
+	const template = table(config)?.ok.get(original) ?? original;
+	return template.replace(PLACEHOLDER, (whole, name: string) => (name in vars ? String(vars[name]) : whole));
+}
+
+/**
+ * The text for a string whose placeholders are elements (a link inside a
+ * sentence): the parts to render, in order.
+ *
+ *   {textParts(config, "This is for members. {signIn} to read on.", { signIn: <a href={u}>Sign in</a> })}
+ */
+export function textParts(config: RedeemIDConfig | null | undefined, original: string, slots: Record<string, unknown>): unknown[] {
+	const template = table(config)?.ok.get(original) ?? original;
+	const out: unknown[] = [];
+	let last = 0;
+	for (const m of template.matchAll(PLACEHOLDER)) {
+		const name = m[1] as string;
+		if (!(name in slots)) continue;
+		if (m.index > last) out.push(template.slice(last, m.index));
+		out.push(slots[name]);
+		last = m.index + m[0].length;
+	}
+	if (last < template.length) out.push(template.slice(last));
+	return out;
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.0.9";
+export const VERSION = "0.0.10";