@swf2es/player-hosts 0.0.0-stage → 0.1.1

package/dist/thread/player/playerglobal/flash/globalization/CurrencyFormatter.js

@@ -0,0 +1,272 @@
+// flash.globalization.CurrencyFormatter: NumberFormatter's settings and
+// digits, placed with the currency by Windows' currency formats, which
+// are Flash's. A locale's own formats are found in Intl's: its accounting
+// format, which ICU gives the parentheses Windows uses, is its negative one.
+import { avm2 } from "../../../../runtime/index.js";
+import { availableLocales, currencyOf, ILLEGAL_ARGUMENT_ERROR, NO_ERROR, nonNull, PARSE_ERROR, resolveLocale, UNSUPPORTED_ERROR, } from "./locale.js";
+import { digit, NumberSettings, partsPattern } from "./NumberFormatter.js";
+// Windows' positive and negative currency formats: "$" the currency, "-" the negative symbol, "n" the number.
+const POSITIVE = ["$n", "n$", "$ n", "n $"];
+const NEGATIVE = [
+    "($n)",
+    "-$n",
+    "$-n",
+    "$n-",
+    "(n$)",
+    "-n$",
+    "n-$",
+    "n$-",
+    "-n $",
+    "-$ n",
+    "n $-",
+    "$ n-",
+    "$ -n",
+    "n- $",
+    "($ n)",
+    "(n $)",
+];
+const currencyData = new Map();
+function localeCurrency(locale) {
+    let data = currencyData.get(locale);
+    if (data) {
+        return data;
+    }
+    const code = currencyOf(locale);
+    // A narrow symbol has ICU place it as the locale's pattern says, with no spacing of its own;
+    // a region with no currency of its own (XDR) is placed as the dollar would be.
+    const options = {
+        style: "currency",
+        currency: code === "XDR" ? "USD" : code,
+        currencyDisplay: "narrowSymbol",
+    };
+    const parts = new Intl.NumberFormat(locale, options).formatToParts(1234.5);
+    const accounting = new Intl.NumberFormat(locale, { ...options, currencySign: "accounting" });
+    const own = new Intl.NumberFormat(locale, { style: "currency", currency: code });
+    data = {
+        code,
+        // The narrow symbol is Windows' ("$" in Hong Kong, not "HK$"); Windows gives a region of
+        // several countries' currency none.
+        symbol: code === "XDR" ? "" : (parts.find((p) => p.type === "currency")?.value ?? code),
+        digits: own.resolvedOptions().maximumFractionDigits ?? 2,
+        positive: Math.max(0, POSITIVE.indexOf(partsPattern(parts))),
+        negative: Math.max(0, NEGATIVE.indexOf(partsPattern(accounting.formatToParts(-1234.5)))),
+    };
+    currencyData.set(locale, data);
+    return data;
+}
+class CurrencySettings extends NumberSettings {
+    currencyISOCode;
+    currencySymbol;
+    positiveFormat;
+    negativeCurrencyFormat;
+    constructor(locale) {
+        super(locale);
+        const data = localeCurrency(locale.actual);
+        this.currencyISOCode = data.code;
+        this.currencySymbol = data.symbol;
+        this.fractionalDigits = data.digits;
+        this.positiveFormat = data.positive;
+        this.negativeCurrencyFormat = data.negative;
+    }
+    /**
+     * A currency amount filling `text` but for spaces, as the negative format
+     * or the positive one places it: the currency is what stands where the
+     * pattern has it, spaces allowed between it and the number.
+     */
+    parseCurrency(text) {
+        if (text === "") {
+            this.status = ILLEGAL_ARGUMENT_ERROR;
+            return { value: Number.NaN, symbol: "" };
+        }
+        for (const negative of [true, false]) {
+            const pattern = negative
+                ? NEGATIVE[this.negativeCurrencyFormat]
+                : POSITIVE[this.positiveFormat];
+            const groups = this.patternRegExp(pattern).exec(text)?.groups;
+            if (groups) {
+                const digits = groups.number;
+                let number = "";
+                for (let i = 0; i < digits.length; i++) {
+                    const d = digit(digits, i);
+                    number += d >= 0 ? d : digits.startsWith(this.decimalSeparator, i) ? "." : "";
+                }
+                this.status = NO_ERROR;
+                return { value: negative ? -Number(number) : Number(number), symbol: groups.symbol ?? "" };
+            }
+        }
+        this.status = PARSE_ERROR;
+        return { value: Number.NaN, symbol: "" };
+    }
+    patternRegExp(pattern) {
+        const literal = (text) => text.replace(/[\\^$.*+?()[\]{}|/]/g, "\\$&");
+        const sign = literal(this.negativeSymbol);
+        // A currency holds no sign or parentheses; it begins with no space before the number and
+        // ends with none after it, where one space parts them and any more are the currency's.
+        // Before the number it is as short as leaves one ("$.5" is "$" and .5), but a number does
+        // not begin after a decimal separator ("$.5.5").
+        const not = `()\\u2212${this.negativeSymbol.replace(/[\\\]^-]/g, "\\$&")}`;
+        const symbolBefore = `(?<symbol>[^\\p{Nd}\\p{Zs}${not}](?:[^\\p{Nd}${not}]*?[^\\p{Nd}${not}])??)?`;
+        const symbolAfter = `(?<symbol>[^${not}](?:[^${not}]*[^\\p{Zs}${not}])?)?`;
+        const group = this.groupingSeparator === "" ? "" : `(?:${literal(this.groupingSeparator)})?`;
+        const decimal = literal(this.decimalSeparator);
+        const number = `(?<!${decimal})(?<number>\\p{Nd}(?:${group}\\p{Nd})*(?:${decimal}\\p{Nd}*)?|${decimal}\\p{Nd}+)`;
+        const before = pattern.indexOf("$") < pattern.indexOf("n");
+        let source = "";
+        let previous = "";
+        let spaced = false;
+        for (const c of pattern) {
+            if (c === " ") {
+                spaced = true;
+                continue;
+            }
+            if (spaced || (c === "$" && previous === "n") || (c === "n" && previous === "$")) {
+                source += "\\p{Zs}?";
+            }
+            switch (c) {
+                case "(":
+                case ")":
+                    source += `\\${c}`;
+                    break;
+                case "-":
+                    source += sign;
+                    break;
+                case "$":
+                    source += before ? symbolBefore : symbolAfter;
+                    break;
+                case "n":
+                    source += number;
+                    break;
+            }
+            previous = c;
+            spaced = false;
+        }
+        return new RegExp(`^\\p{Zs}*${source}\\p{Zs}*$`, "u");
+    }
+}
+export function currencyFormatterNatives(s) {
+    const natives = {};
+    const settings = (o) => o.$settings;
+    class CurrencyFormatterNatives {
+        static getAvailableLocaleIDNames() {
+            return availableLocales(s);
+        }
+        "flash.globalization:CurrencyFormatter::ctor"(name) {
+            this.$settings = new CurrencySettings(resolveLocale(s, nonNull(s, name, "requestedLocaleIDName")));
+        }
+        get lastOperationStatus() {
+            return settings(this).status;
+        }
+        get requestedLocaleIDName() {
+            return settings(this).locale.requested;
+        }
+        get actualLocaleIDName() {
+            return settings(this).locale.actual;
+        }
+        get currencyISOCode() {
+            return settings(this).currencyISOCode;
+        }
+        get currencySymbol() {
+            return settings(this).currencySymbol;
+        }
+        setCurrency(code, symbol) {
+            const f = settings(this);
+            nonNull(s, code, "currencyISOCode");
+            nonNull(s, symbol, "currencySymbol");
+            const valid = /^[A-Z]{3}$/.test(code);
+            if (valid) {
+                f.currencyISOCode = code;
+                f.currencySymbol = symbol;
+            }
+            f.status = valid ? NO_ERROR : ILLEGAL_ARGUMENT_ERROR;
+        }
+        "flash.globalization:CurrencyFormatter::formatImplementation"(value, withSymbol) {
+            const f = settings(this);
+            return f.format(value, (negative) => (negative ? NEGATIVE[f.negativeCurrencyFormat] : POSITIVE[f.positiveFormat]), withSymbol ? f.currencySymbol : f.currencyISOCode);
+        }
+        formattingWithCurrencySymbolIsSafe(code) {
+            const f = settings(this);
+            f.status = NO_ERROR;
+            return nonNull(s, code, "requestedISOCode") === f.currencyISOCode;
+        }
+        parse(text) {
+            const { value, symbol } = settings(this).parseCurrency(nonNull(s, text, "value"));
+            return s.rt.construct(s.rt.classNamed("flash.globalization::CurrencyParseResult"), value, symbol);
+        }
+        get fractionalDigits() {
+            return settings(this).fractionalDigits;
+        }
+        set fractionalDigits(n) {
+            settings(this).setFractionalDigits(n);
+        }
+        get useGrouping() {
+            return settings(this).useGrouping;
+        }
+        set useGrouping(v) {
+            settings(this).set("useGrouping", v);
+        }
+        get groupingPattern() {
+            return settings(this).groupingPattern;
+        }
+        set groupingPattern(v) {
+            settings(this).setGroupingPattern(nonNull(s, v, "value"));
+        }
+        get digitsType() {
+            return settings(this).digitsType;
+        }
+        set digitsType(v) {
+            settings(this).setDigitsType(v);
+        }
+        get decimalSeparator() {
+            return settings(this).decimalSeparator;
+        }
+        set decimalSeparator(v) {
+            settings(this).setDecimalSeparator(nonNull(s, v, "value"));
+        }
+        get groupingSeparator() {
+            return settings(this).groupingSeparator;
+        }
+        set groupingSeparator(v) {
+            settings(this).setGroupingSeparator(nonNull(s, v, "value"));
+        }
+        get negativeSymbol() {
+            return settings(this).negativeSymbol;
+        }
+        // Windows keeps the locale's.
+        set negativeSymbol(v) {
+            nonNull(s, v, "value");
+            settings(this).status = UNSUPPORTED_ERROR;
+        }
+        get negativeCurrencyFormat() {
+            return settings(this).negativeCurrencyFormat;
+        }
+        set negativeCurrencyFormat(n) {
+            const f = settings(this);
+            if (f.setFormat(n, NEGATIVE.length)) {
+                f.negativeCurrencyFormat = n;
+            }
+        }
+        get positiveCurrencyFormat() {
+            return settings(this).positiveFormat;
+        }
+        set positiveCurrencyFormat(n) {
+            const f = settings(this);
+            if (f.setFormat(n, POSITIVE.length)) {
+                f.positiveFormat = n;
+            }
+        }
+        get leadingZero() {
+            return settings(this).leadingZero;
+        }
+        set leadingZero(v) {
+            settings(this).set("leadingZero", v);
+        }
+        get trailingZeros() {
+            return settings(this).trailingZeros;
+        }
+        set trailingZeros(v) {
+            settings(this).set("trailingZeros", v);
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::CurrencyFormatter", CurrencyFormatterNatives);
+    return natives;
+}

package/dist/thread/player/playerglobal/flash/globalization/CurrencyParseResult.js

@@ -0,0 +1,21 @@
+import { avm2 } from "../../../../runtime/index.js";
+export function currencyParseResultNatives(s) {
+    const natives = {};
+    class CurrencyParseResultNatives {
+        "flash.globalization:CurrencyParseResult::ctor"(value, symbol) {
+            if (symbol === null) {
+                throw s.rt.error("TypeError", 2007, "symbol");
+            }
+            this.$currencyValue = value;
+            this.$currencyString = symbol;
+        }
+        get value() {
+            return this.$currencyValue;
+        }
+        get currencyString() {
+            return this.$currencyString;
+        }
+    }
+    avm2.registerNativeClass(natives, "flash.globalization::CurrencyParseResult", CurrencyParseResultNatives);
+    return natives;
+}