@drip-apex/sdk 0.1.0 → 0.2.0

package/src/js.ts

@@ -2,6 +2,47 @@ import type { CustomJsPolicy } from "./types";
 
 let activePolicy: CustomJsPolicy = "hybrid";
 const EXTERNAL_JS_CLASS = "drip-external-js";
+type ExternalJsJournalEntry = {
+  seq: number;
+  artifactId: string;
+  epoch: number;
+  owners: Set<string>;
+  target: Element;
+  state: "applied" | "invalidated";
+};
+const externalJsJournal: ExternalJsJournalEntry[] = [];
+let externalJsSequence = 0;
+
+function recordExternalJs(
+  element: Element,
+  artifactId: string,
+  ownerKeys: readonly string[],
+  epoch: number,
+): void {
+  const existing = externalJsJournal.find(
+    (entry) => entry.target === element && entry.artifactId === artifactId,
+  );
+  if (existing) {
+    ownerKeys.forEach((ownerKey) => existing.owners.add(ownerKey));
+    existing.state = "applied";
+    existing.epoch = epoch;
+    return;
+  }
+  externalJsJournal.push({
+    seq: ++externalJsSequence,
+    artifactId,
+    epoch,
+    owners: new Set(ownerKeys),
+    target: element,
+    state: "applied",
+  });
+}
+
+function forgetExternalJs(element: Element): void {
+  for (let index = externalJsJournal.length - 1; index >= 0; index -= 1) {
+    if (externalJsJournal[index].target === element) externalJsJournal.splice(index, 1);
+  }
+}
 
 export function setJsPolicy(policy: CustomJsPolicy): void {
   activePolicy = policy;
@@ -29,7 +70,13 @@ export function execJs(code: string, sourceLabel?: string): void {
   }
 }
 
-export function loadExternalJs(url: string, sourceLabel: string): Promise<void> {
+export function loadExternalJs(
+  url: string,
+  sourceLabel: string,
+  ownerKeys: readonly string[] = [],
+  artifactId = "js:external:" + sourceLabel,
+  epoch = 0,
+): Promise<void> {
   if (activePolicy === "strict") {
     if (typeof console !== "undefined") {
       console.warn("[drip] External JS blocked by strict policy for " + sourceLabel);
@@ -40,22 +87,59 @@ export function loadExternalJs(url: string, sourceLabel: string): Promise<void>
     const id = "drip-external-js-" + sourceLabel;
     const previous = document.getElementById(id);
     if (previous && previous.getAttribute("src") === url) {
+      recordExternalJs(previous, artifactId, ownerKeys, epoch);
       resolve();
       return;
     }
-    if (previous) previous.remove();
+    if (previous) {
+      forgetExternalJs(previous);
+      previous.remove();
+    }
 
     const script = document.createElement("script");
     script.id = id;
     script.className = EXTERNAL_JS_CLASS;
     script.src = url;
     script.async = false;
+    recordExternalJs(script, artifactId, ownerKeys, epoch);
     script.onload = () => resolve();
     script.onerror = () => reject(new Error("Failed to load JS artifact: " + url));
     (document.head || document.documentElement).appendChild(script);
   });
 }
 
+export function removeExternalJsForOwner(ownerKey: string, artifactId?: string): void {
+  const removed = new Set<Element>();
+  for (let index = externalJsJournal.length - 1; index >= 0; index -= 1) {
+    const entry = externalJsJournal[index];
+    if (artifactId !== undefined && entry.artifactId !== artifactId) continue;
+    if (!entry.owners.delete(ownerKey) || entry.owners.size > 0) continue;
+    removed.add(entry.target);
+    externalJsJournal.splice(index, 1);
+  }
+  for (const element of removed) {
+    if (!externalJsJournal.some((entry) => entry.target === element)) element.remove();
+  }
+}
+
+export function addExternalJsOwners(
+  existingOwnerKeys: ReadonlySet<string>,
+  ownerKeys: readonly string[],
+  artifactId?: string,
+): void {
+  if (existingOwnerKeys.size === 0 || ownerKeys.length === 0) return;
+  for (const entry of externalJsJournal) {
+    if (artifactId !== undefined && entry.artifactId !== artifactId) continue;
+    if (
+      !Array.from(existingOwnerKeys).some((ownerKey) =>
+        entry.owners.has(ownerKey)
+      )
+    ) continue;
+    ownerKeys.forEach((ownerKey) => entry.owners.add(ownerKey));
+  }
+}
+
 export function removeAllExternalJs(): void {
   document.querySelectorAll("." + EXTERNAL_JS_CLASS).forEach((el) => el.remove());
+  externalJsJournal.length = 0;
 }

package/src/money.test.ts

@@ -1,7 +1,34 @@
 import { describe, expect, it } from "vitest";
-import { formatCentsLike, parseDisplayedCents } from "./money";
+import {
+  currencyExponent,
+  extractCurrencyTokens,
+  formatCentsLike,
+  parseDisplayedCents,
+} from "./money";
+
+describe("currency precision", () => {
+  it("uses the static ISO-4217 exponent table", () => {
+    expect(currencyExponent("JPY")).toBe(0);
+    expect(currencyExponent("UYI")).toBe(0);
+    expect(currencyExponent("EUR")).toBe(2);
+    expect(currencyExponent("BHD")).toBe(3);
+    expect(currencyExponent("KWD")).toBe(3);
+    expect(currencyExponent("CLF")).toBe(4);
+    expect(() => currencyExponent("ZZZ")).toThrow(/Unknown ISO-4217/);
+  });
+});
 
 describe("money display parsing", () => {
+  it("keeps ISO-code boundaries and extracts a mid-string suffix token", () => {
+    expect(extractCurrencyTokens("ABCEUR 12,00")).toEqual([]);
+    expect(extractCurrencyTokens("EUR 12,00")).toEqual([
+      { symbol: "EUR", cents: 1200, raw: "EUR 12,00" },
+    ]);
+    expect(extractCurrencyTokens("Before 1.299,95 \u20ac after")).toEqual([
+      { symbol: "\u20ac", cents: 129995, raw: "1.299,95 \u20ac" },
+    ]);
+  });
+
   it.each([
     ["$1,299.00", 129900, "1,149.95"],
     ["€1.299,00", 129900, "1.149,95"],
@@ -29,6 +56,33 @@ describe("money display parsing", () => {
     expect(parsed && formatCentsLike(1123, parsed.convention)).toBe("1.123");
   });
 
+  it.each([
+    ["¥1,234", 0, 1234],
+    ["CLF 1,234", 4, 12_340_000],
+  ])(
+    "preserves grouped whole amounts at non-two-decimal scales: %s",
+    (text, minorUnits, expected) => {
+      const parsed = parseDisplayedCents(text, minorUnits);
+      expect(parsed?.cents).toBe(expected);
+      expect(parsed && formatCentsLike(expected, parsed.convention)).toContain(
+        "1,234",
+      );
+    },
+  );
+
+  it("keeps a mixed-separator fractional amount unambiguous", () => {
+    expect(parseDisplayedCents("KD 1.234,567", 3)?.cents).toBe(1_234_567);
+  });
+
+  it("keeps repeated comma groups unambiguous", () => {
+    expect(parseDisplayedCents("KD 1,234,567", 3)?.cents).toBe(1_234_567_000);
+  });
+
+  it("rejects a lone comma with three trailing digits for three-decimal currencies", () => {
+    expect(parseDisplayedCents("KD 1,234", 3)).toBeNull();
+    expect(parseDisplayedCents("$1,234", 2)?.cents).toBe(123_400);
+  });
+
   it.each(["10 and 20", "no digits"])("rejects ambiguous or absent amounts: %s", (text) => {
     expect(parseDisplayedCents(text)).toBeNull();
   });

package/src/money.ts

@@ -12,6 +12,81 @@ export type DisplayedMoney = {
   end: number;
 };
 
+export type CurrencyToken = {
+  symbol: string;
+  cents: number;
+  raw: string;
+};
+
+/** Extract marked displayed prices without treating ordinary numbers as money. */
+export function extractCurrencyTokens(text: string): CurrencyToken[] {
+  const tokens: CurrencyToken[] = [];
+  const amount = String.raw`\d(?:[\d.,\u00a0 ]*\d)?`;
+  const symbol = String.raw`[$\u20ac\u00a3\u00a5\u20b9]`;
+  const pattern = new RegExp(
+    String.raw`(?:(${symbol})\s*(${amount})|(?:^|([^A-Z]))([A-Z]{3})\s*(${amount})|(${amount})\s*(${symbol}|[A-Z]{3}|kr)(?![A-Za-z]))`,
+    "g",
+  );
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(text)) !== null) {
+    const consumedPrefix = match[3] ?? "";
+    const raw = match[0].slice(consumedPrefix.length);
+    const marker = match[1] ?? match[4] ?? match[7];
+    const displayedAmount = match[2] ?? match[5] ?? match[6];
+    if (/^[A-Z]{3}$/.test(marker) && !ISO_4217_CURRENCY_CODE_SET.has(marker)) {
+      continue;
+    }
+    const parsed = parseDisplayedCents(displayedAmount);
+    if (parsed) tokens.push({
+      symbol: marker,
+      cents: parsed.cents,
+      raw,
+    });
+  }
+  return tokens;
+}
+export const ISO_4217_CURRENCY_CODES =
+  `AED AFN ALL AMD ANG AOA ARS AUD AWG AZN BAM BBD BDT BGN BHD BIF BMD BND BOB BOV BRL BSD BTN BWP BYN BZD CAD CDF CHE CHF CHW CLF CLP CNY COP COU CRC CUP CVE CZK DJF DKK DOP DZD EGP ERN ETB EUR FJD FKP GBP GEL GHS GIP GMD GNF GTQ GYD HKD HNL HRK HTG HUF IDR ILS INR IQD IRR ISK JMD JOD JPY KES KGS KHR KMF KPW KRW KWD KYD KZT LAK LBP LKR LRD LSL LYD MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MXV MYR MZN NAD NGN NIO NOK NPR NZD OMR PAB PEN PGK PHP PKR PLN PYG QAR RON RSD RUB RWF SAR SBD SCR SDG SEK SGD SHP SLE SOS SRD SSP STN SVC SYP SZL THB TJS TMT TND TOP TRY TTD TWD TZS UAH UGX USD USN UYI UYU UYW UZS VES VND VUV WST XAF XCD XCG XDR XOF XPF XSU YER ZAR ZMW ZWG`.split(
+    " ",
+  );
+const ISO_4217_CURRENCY_CODE_SET = new Set(ISO_4217_CURRENCY_CODES);
+
+// Precision is a read-compatibility contract as well as a write-time concern.
+// Keep withdrawn codes that can exist on stored shops/experiments here even
+// though the assigned-code set above intentionally rejects them on new writes.
+const ISO_4217_PRECISION_CODE_SET = new Set([
+  ...ISO_4217_CURRENCY_CODES,
+  "CUC",
+  "SLL",
+  "ZWL",
+]);
+
+/** Returns whether a code is currently active in ISO 4217. */
+export function isIso4217CurrencyCode(currencyCode: string): boolean {
+  return ISO_4217_CURRENCY_CODE_SET.has(currencyCode.trim().toUpperCase());
+}
+
+const ZERO_DECIMAL_CURRENCIES = new Set(
+  `BIF CLP DJF GNF ISK JPY KMF KRW PYG RWF UGX UYI VND VUV XAF XOF XPF`.split(
+    " ",
+  ),
+);
+const THREE_DECIMAL_CURRENCIES = new Set(
+  `BHD IQD JOD KWD LYD OMR TND`.split(" "),
+);
+
+/** Authoritative ISO-4217 minor-unit exponent for editor-supported currencies. */
+export function currencyExponent(currencyCode: string): number {
+  if (!ISO_4217_PRECISION_CODE_SET.has(currencyCode)) {
+    throw new RangeError(
+      `Unknown ISO-4217 currency precision: ${currencyCode}`,
+    );
+  }
+  if (ZERO_DECIMAL_CURRENCIES.has(currencyCode)) return 0;
+  if (THREE_DECIMAL_CURRENCIES.has(currencyCode)) return 3;
+  if (currencyCode === "CLF" || currencyCode === "UYW") return 4;
+  return 2;
+}
 export function parseDisplayedCents(text: string, minorUnits = 2): DisplayedMoney | null {
   const pattern = /\d(?:[\d.,\u00a0 ]*\d)?/g;
   const match = pattern.exec(text);
@@ -20,7 +95,35 @@ export function parseDisplayedCents(text: string, minorUnits = 2): DisplayedMone
   const compact = raw.replace(/[ \u00a0]/g, "");
   const separator = Math.max(compact.lastIndexOf("."), compact.lastIndexOf(","));
   const trailing = separator < 0 ? 0 : compact.length - separator - 1;
-  const decimals = trailing && trailing <= minorUnits ? trailing : 0;
+  const separatorCharacter = separator < 0 ? "" : compact[separator];
+  const repeatedSeparator =
+    separatorCharacter !== "" && compact.indexOf(separatorCharacter) !== separator;
+  const hasOtherSeparator =
+    separatorCharacter === ","
+      ? compact.includes(".")
+      : separatorCharacter === "." && compact.includes(",");
+  // A lone comma before exactly three digits can be either a decimal mark or
+  // a thousands separator in a three-decimal currency. Fail closed unless
+  // another separator provides enough evidence to select one convention.
+  if (
+    minorUnits === 3 &&
+    trailing === 3 &&
+    separatorCharacter === "," &&
+    !repeatedSeparator &&
+    !hasOtherSeparator
+  ) {
+    return null;
+  }
+  // Scaled-currency themes can omit a zero fractional part. Preserve a
+  // comma-separated three-digit group as a whole amount unless another
+  // separator makes the fractional convention explicit.
+  const groupedWhole =
+    trailing === 3 &&
+    minorUnits !== 2 &&
+    !hasOtherSeparator &&
+    (separatorCharacter === "," || repeatedSeparator);
+  const decimals =
+    trailing && trailing <= minorUnits && !groupedWhole ? trailing : 0;
 
   const visibleDecimal = decimals ? compact[separator] as "." | "," : null;
   const groupMatch = raw.slice(0, visibleDecimal ? raw.lastIndexOf(visibleDecimal) : raw.length).match(/[.,\u00a0 ]/);
@@ -40,7 +143,6 @@ export function parseDisplayedCents(text: string, minorUnits = 2): DisplayedMone
     end: match.index + raw.length,
   };
 }
-
 export function formatCentsLike(cents: number, convention: MoneyConvention): string {
   const scale = 10 ** convention.minorUnits;
   let major = String(Math.floor(cents / scale));

package/src/money.web-parity.contract.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import {
+  currencyExponent as sdkCurrencyExponent,
+  extractCurrencyTokens as extractSdkCurrencyTokens,
+  isIso4217CurrencyCode as isSdkIso4217CurrencyCode,
+  ISO_4217_CURRENCY_CODES,
+  parseDisplayedCents as parseSdkDisplayedCents,
+} from "./money";
+import {
+  currencyExponent as webCurrencyExponent,
+  extractCurrencyTokens as extractWebCurrencyTokens,
+  isIso4217CurrencyCode as isWebIso4217CurrencyCode,
+  parseDisplayedCents as parseWebDisplayedCents,
+} from "../../../apps/web/src/lib/commerce-editors/money";
+
+const currencyVectors = [
+  ...ISO_4217_CURRENCY_CODES,
+  "CUC",
+  "SLL",
+  "ZWL",
+  "XXX",
+  "ZZZ",
+  "usd",
+  "",
+];
+
+const displayedMoneyVectors: Array<[text: string, minorUnits: number]> = [
+  ["0", 0],
+  ["0", 2],
+  ["0.005", 3],
+  ["USD 0.005", 3],
+  ["$0.005", 3],
+  ["1.005", 2],
+  ["1.005", 3],
+  ["1,005", 3],
+  ["-1.005", 3],
+  ["JPY 123456789", 0],
+  ["USD 123456789.99", 2],
+  ["BHD 123456789.999", 3],
+  ["123456789.999 BHD", 3],
+  ["€1,234.56", 2],
+  ["1.234,56 EUR", 2],
+  ["1 234,56 kr", 2],
+  ["USD 10 and USD 20", 2],
+  ["not money", 2],
+  ["ZZZ 10.00", 2],
+];
+
+function resultOf<T>(callback: () => T): { value: T } | { error: string } {
+  try {
+    return { value: callback() };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? `${error.name}: ${error.message}` : String(error),
+    };
+  }
+}
+
+describe("web money behavior parity", () => {
+  it.each(currencyVectors)("resolves currency exponent %j identically", (code) => {
+    expect(resultOf(() => webCurrencyExponent(code))).toEqual(
+      resultOf(() => sdkCurrencyExponent(code)),
+    );
+  });
+
+  it.each(currencyVectors)("recognizes ISO currency %j identically", (code) => {
+    expect(isWebIso4217CurrencyCode(code)).toBe(isSdkIso4217CurrencyCode(code));
+  });
+
+  it.each(displayedMoneyVectors)(
+    "parses displayed amount %j at exponent %i identically",
+    (text, minorUnits) => {
+      expect(parseWebDisplayedCents(text, minorUnits)).toEqual(
+        parseSdkDisplayedCents(text, minorUnits),
+      );
+    },
+  );
+
+  it.each(displayedMoneyVectors)(
+    "extracts currency tokens from %j identically",
+    (text) => {
+      expect(extractWebCurrencyTokens(text)).toEqual(extractSdkCurrencyTokens(text));
+    },
+  );
+});