@poe-platform/safe-js 0.1.288 → 0.1.289

package/README.md

@@ -103,8 +103,6 @@ Current-time reads are recorded for replay; replay does not call `now()` again.
 
 Date values copy by value across host bindings, preserving aliases within a graph. Checkpoints preserve epoch values, invalid dates and mutations rather than converting dates to strings. Parsing is limited to 4,096 characters and consumes the work/string budgets; retained values consume data budget. Local methods and non-ISO parsing follow the host timezone/runtime, so use explicit-zone ISO strings and UTC methods for portable output.
 
-Unsupported: locale formatting, legacy `getYear`/`setYear`/`toGMTString`, subclassing, custom argument coercion, Date-instance own properties and prototype modification. These are restrictions, not stubs; no native constructor or prototype is exposed to guest code.
-
 </details>
 
 ## Add a host capability

package/dist/safe-js/chunks/{chunk-LOPY7ITQ.js → chunk-BNVOTMJ4.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-K45MDTVS.js";
+} from "./chunk-KKMT52LR.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-LOPY7ITQ.js.map
+//# sourceMappingURL=chunk-BNVOTMJ4.js.map

package/dist/safe-js/chunks/{chunk-K45MDTVS.js → chunk-KKMT52LR.js}

@@ -6966,6 +6966,9 @@ var methodNames = [
   "setUTCSeconds",
   "toDateString",
   "toISOString",
+  "toLocaleString",
+  "toLocaleDateString",
+  "toLocaleTimeString",
   "toString",
   "toTimeString",
   "toUTCString",
@@ -20366,6 +20369,111 @@ async function parseJsonWithReviver(text, reviver, budget, context) {
   }
 }
 
+// packages/safe-js/src/interp/date-locale.ts
+var NativeDateTimeFormat = Intl.DateTimeFormat;
+var canonicalLocales = Intl.getCanonicalLocales;
+var dateTimeOptions = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["calendar", "unicodeType"],
+  ["numberingSystem", "unicodeType"],
+  ["hour12", "boolean"],
+  ["hourCycle", ["h11", "h12", "h23", "h24"]],
+  ["timeZone", "zone"],
+  ["weekday", ["narrow", "short", "long"]],
+  ["era", ["narrow", "short", "long"]],
+  ["year", ["2-digit", "numeric"]],
+  ["month", ["2-digit", "numeric", "narrow", "short", "long"]],
+  ["day", ["2-digit", "numeric"]],
+  ["dayPeriod", ["narrow", "short", "long"]],
+  ["hour", ["2-digit", "numeric"]],
+  ["minute", ["2-digit", "numeric"]],
+  ["second", ["2-digit", "numeric"]],
+  ["fractionalSecondDigits", "number"],
+  ["timeZoneName", ["short", "long", "shortOffset", "longOffset", "shortGeneric", "longGeneric"]],
+  ["formatMatcher", ["basic", "best fit"]],
+  ["dateStyle", ["full", "long", "medium", "short"]],
+  ["timeStyle", ["full", "long", "medium", "short"]]
+];
+async function formatDateLocale(name, time, args, budget, context) {
+  if (Number.isNaN(time)) return budget.allocateString("Invalid Date");
+  const locales = [];
+  const options = /* @__PURE__ */ Object.create(null);
+  const release = retainValues(budget, () => [locales, options]);
+  const read = (value, key) => {
+    budget.visitNode();
+    if (context?.getProperty !== void 0) return context.getProperty(value, key);
+    const descriptor = getSandboxPropertyDescriptor(value, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, value, context);
+  };
+  const toObject = (value) => {
+    if (value === null || value === void 0) throw new TypeError("Cannot convert null or undefined to an object.");
+    if (typeof value === "object") return value;
+    const box = createSandboxBox(value);
+    allocateProducedSandboxValue(box, budget);
+    return box;
+  };
+  try {
+    const inputLocales = args[0];
+    if (inputLocales !== void 0) {
+      const list2 = typeof inputLocales === "string" ? [inputLocales] : toObject(inputLocales);
+      const count = await sandboxNumber(await read(list2, "length"), budget, context);
+      const length = Number.isNaN(count) || count <= 0 ? 0 : Math.min(Math.floor(count), Number.MAX_SAFE_INTEGER);
+      for (let index = 0; index < length; index++) {
+        budget.visitNode();
+        const key = String(index);
+        if (getSandboxPropertyDescriptor(list2, key, budget) === void 0 && !(isFloat32Array(list2) && Object.hasOwn(list2, key))) continue;
+        const value = await read(list2, key);
+        if (typeof value !== "string" && (typeof value !== "object" || value === null))
+          throw new TypeError("Locale entries must be strings or objects.");
+        const tag = await sandboxString(value, budget, context);
+        budget.visitNode(tag.length);
+        const canonical = canonicalLocales(tag)[0];
+        budget.visitNode(locales.length);
+        if (!locales.includes(canonical)) locales.push(budget.allocateString(canonical));
+      }
+    }
+    const inputOptions = args[1] === void 0 ? /* @__PURE__ */ Object.create(null) : toObject(args[1]);
+    for (const [key, type] of dateTimeOptions) {
+      const value = await read(inputOptions, key);
+      if (value === void 0) continue;
+      if (type === "boolean") options[key] = Boolean(value);
+      else if (type === "number") {
+        const number = await sandboxNumber(value, budget, context);
+        if (!Number.isFinite(number) || number < 1 || number > 3)
+          throw new RangeError("fractionalSecondDigits must be between 1 and 3.");
+        options[key] = Math.floor(number);
+      } else {
+        const text = await sandboxString(value, budget, context);
+        budget.visitNode(text.length);
+        if (type === "unicodeType") {
+          const valid = text.split("-").every((part) => part.length >= 3 && part.length <= 8 && [...part].every((char) => char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char >= "0" && char <= "9"));
+          if (!valid) throw new RangeError(`Invalid ${key} option.`);
+        } else if (type === "zone") {
+          new NativeDateTimeFormat("en", { timeZone: text });
+        } else if (!type.includes(text)) throw new RangeError(`Invalid ${key} option.`);
+        options[key] = text;
+      }
+    }
+    const date = name !== "toLocaleTimeString";
+    const clock = name !== "toLocaleDateString";
+    if (options.dateStyle !== void 0 || options.timeStyle !== void 0) {
+      if (!date && options.dateStyle !== void 0 || !clock && options.timeStyle !== void 0)
+        throw new TypeError("Date/time style is incompatible with this locale method.");
+    } else {
+      const hasDate = date && ["weekday", "year", "month", "day"].some((key) => options[key] !== void 0);
+      const hasTime = clock && ["dayPeriod", "hour", "minute", "second", "fractionalSecondDigits"].some((key) => options[key] !== void 0);
+      if (!hasDate && !hasTime) {
+        if (date) for (const key of ["year", "month", "day"]) options[key] = "numeric";
+        if (clock) for (const key of ["hour", "minute", "second"]) options[key] = "numeric";
+      }
+    }
+    const formatter = new NativeDateTimeFormat(locales, options);
+    return budget.allocateString(formatter.format(time));
+  } finally {
+    release();
+  }
+}
+
 // packages/safe-js/src/snapshot/replay-data.ts
 var MissingReplayCapabilityError = class extends TypeError {
 };
@@ -21943,6 +22051,7 @@ function createDateGlobal(options) {
           if (!isSandboxDate(receiver))
             throw new TypeError(`Date#${name} requires a Date receiver.`);
           options.budget.visitNode();
+          if (name.startsWith("toLocale")) return formatDateLocale(name, dateTime(receiver), args, options.budget, context);
           if (name.startsWith("set")) return coerceDateSetter(name, receiver, args, options.budget, context);
           const value = method.invoke(receiver, args);
           return typeof value === "string" ? options.budget.allocateString(value) : value;
@@ -40340,4 +40449,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-K45MDTVS.js.map
+//# sourceMappingURL=chunk-KKMT52LR.js.map