@johnmorrisdotca/kyogijo-stadiums 0.45.2 → 0.45.3

package/dist/strings.core.js

@@ -0,0 +1,55 @@
+/** The languages the words are in. */
+const LANGUAGES = ["en", "ja"];
+/**
+ * The words of the package, by language. Each language is a file of its own (`strings.en.ts`, `strings.ja.ts`), and an entry holds the languages it was given: every entry but the lean district imports `strings.ts`, which holds both, as it always
+ * did; the lean district (`district-lean`) holds none until `loadStrings(language)` has read the language it is about to draw in. Reading a language that is not held throws, naming the call that holds it.
+ */
+export const KYOGIJO_STRINGS = Object.defineProperties({}, Object.fromEntries(LANGUAGES.map((language) => [
+    language,
+    {
+        enumerable: true,
+        configurable: true,
+        get() {
+            throw new Error(`the ${language === "en" ? "English" : "Japanese"} words are not read yet: await loadStrings("${language}") before the first draw in ${language}, or use an entry that holds both languages (the main entry, or any but the lean district's)`);
+        },
+    },
+])));
+/** Hold a language's words for the drawing: what `strings.en.ts` and `strings.ja.ts` do when they are read. After it `KYOGIJO_STRINGS[language]` is the words themselves. */
+export function provideStrings(language, words) {
+    Object.defineProperty(KYOGIJO_STRINGS, language, { value: words, enumerable: true, configurable: true, writable: true });
+}
+/** Whether a language's words are held. */
+export const hasStrings = (language) => {
+    const held = Object.getOwnPropertyDescriptor(KYOGIJO_STRINGS, language);
+    return held !== undefined && held.get === undefined;
+};
+const reading = new Map();
+/**
+ * The words of a language, read from the file of that language (the first time) and held for the drawing: await it before the first call of the lean district that draws in the language, and again when the language changes (a language
+ * whose words are held is not read twice, and asking again gives the same promise). The entries that hold both languages need no call, and it does nothing there. A language there is no file for rejects.
+ * @example
+ * ```ts
+ * import { drawDistrict, loadStrings, loadVenueDataFor } from "@johnmorrisdotca/kyogijo-stadiums/district-lean";
+ * const venues = ["rogers-arena"];
+ * await Promise.all([loadVenueDataFor(venues), loadStrings("ja")]);
+ * console.log(drawDistrict({ venues, language: "ja" }).includes("ロジャーズ"));
+ * // true
+ * ```
+ */
+export function loadStrings(language) {
+    if (hasStrings(language))
+        return Promise.resolve();
+    const found = reading.get(language);
+    if (found !== undefined)
+        return found;
+    const promise = language === "en" ? import("./strings.en.js").then(() => undefined)
+        : language === "ja" ? import("./strings.ja.js").then(() => undefined)
+            : Promise.reject(new Error(`no words in ${JSON.stringify(language)}: the languages are ${LANGUAGES.join(", ")}`));
+    reading.set(language, promise);
+    promise.catch(() => reading.delete(language));
+    return promise;
+}
+/** Fill {placeholders} in a template. */
+export function fill(template, values) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => String(values[key] ?? ""));
+}