@kubohiroya/turbowarp-title-menu 0.1.0

package/dist/lib/dsl-store.js

@@ -0,0 +1,254 @@
+export class DslStoreError extends Error {
+    constructor(code, message, cause) {
+        super(message, cause === undefined ? undefined : { cause });
+        this.name = 'DslStoreError';
+        this.code = code;
+    }
+}
+export const defaultDslSort = Object.freeze({ field: 'updatedAt', direction: 'desc' });
+const fileStoreName = 'files';
+const metaStoreName = 'meta';
+const lastOpenedKey = 'last-opened';
+const nameIndexName = 'by-name';
+const encoder = new TextEncoder();
+const maximumNameLength = 200;
+/** Rejects control characters so a name cannot break the dialog's text rendering. */
+function hasControlCharacter(value) {
+    for (const character of value) {
+        const code = character.codePointAt(0) ?? 0;
+        if (code < 0x20 || code === 0x7f)
+            return true;
+    }
+    return false;
+}
+function normalizeName(value) {
+    if (typeof value !== 'string')
+        throw new DslStoreError('invalid-name', 'DSL name must be a string.');
+    const name = value.trim();
+    if (name.length === 0)
+        throw new DslStoreError('invalid-name', 'DSL name must not be empty.');
+    if (name.length > maximumNameLength) {
+        throw new DslStoreError('invalid-name', `DSL name must be at most ${maximumNameLength} characters.`);
+    }
+    if (hasControlCharacter(name)) {
+        throw new DslStoreError('invalid-name', 'DSL name must not contain control characters.');
+    }
+    return name;
+}
+function request(input) {
+    return new Promise((resolve, reject) => {
+        input.onsuccess = () => resolve(input.result);
+        input.onerror = () => reject(toStoreError(input.error));
+    });
+}
+function transactionDone(transaction) {
+    return new Promise((resolve, reject) => {
+        transaction.oncomplete = () => resolve();
+        transaction.onabort = () => reject(toStoreError(transaction.error));
+        transaction.onerror = () => reject(toStoreError(transaction.error));
+    });
+}
+function toStoreError(cause) {
+    const name = cause?.name;
+    if (name === 'QuotaExceededError') {
+        return new DslStoreError('quota', 'Browser storage is full. Delete a saved DSL file first.', cause);
+    }
+    if (name === 'ConstraintError') {
+        return new DslStoreError('name-taken', 'A DSL file with that name already exists.', cause);
+    }
+    return new DslStoreError('failed', 'The DSL storage operation failed.', cause);
+}
+function compareSummaries(sort) {
+    const direction = sort.direction === 'asc' ? 1 : -1;
+    return (left, right) => {
+        if (sort.field === 'name') {
+            return direction * left.name.localeCompare(right.name, undefined, { numeric: true });
+        }
+        if (sort.field === 'byteLength') {
+            return direction * (left.byteLength - right.byteLength) || left.name.localeCompare(right.name);
+        }
+        return direction * left.updatedAt.localeCompare(right.updatedAt) || left.name.localeCompare(right.name);
+    };
+}
+function toSummary(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        byteLength: record.byteLength,
+        savedAt: record.savedAt,
+        updatedAt: record.updatedAt
+    };
+}
+export function createDslStore(options = {}) {
+    const factory = options.indexedDB ?? globalThis.indexedDB;
+    if (factory === undefined || typeof factory.open !== 'function') {
+        throw new DslStoreError('unavailable', 'IndexedDB is not available in this environment.');
+    }
+    const databaseName = options.databaseName ?? 'turbowarp-title-menu';
+    const maxSourceBytes = options.maxSourceBytes ?? 1024 * 1024;
+    const maxFileCount = options.maxFileCount ?? 64;
+    const now = options.now ?? (() => new Date());
+    const createId = options.createId ?? defaultCreateId;
+    let connection = null;
+    function open() {
+        connection ?? (connection = new Promise((resolve, reject) => {
+            const opening = factory.open(databaseName, 1);
+            opening.onupgradeneeded = () => {
+                const database = opening.result;
+                if (!database.objectStoreNames.contains(fileStoreName)) {
+                    const files = database.createObjectStore(fileStoreName, { keyPath: 'id' });
+                    files.createIndex(nameIndexName, 'name', { unique: true });
+                }
+                if (!database.objectStoreNames.contains(metaStoreName)) {
+                    database.createObjectStore(metaStoreName, { keyPath: 'key' });
+                }
+            };
+            opening.onsuccess = () => resolve(opening.result);
+            opening.onerror = () => reject(toStoreError(opening.error));
+            opening.onblocked = () => reject(new DslStoreError('failed', 'Another tab is upgrading the DSL database.'));
+        }));
+        return connection;
+    }
+    async function readAll() {
+        const database = await open();
+        const transaction = database.transaction(fileStoreName, 'readonly');
+        const records = await request(transaction.objectStore(fileStoreName).getAll());
+        await transactionDone(transaction);
+        return records;
+    }
+    async function readOne(id) {
+        const database = await open();
+        const transaction = database.transaction(fileStoreName, 'readonly');
+        const record = await request(transaction.objectStore(fileStoreName).get(id));
+        await transactionDone(transaction);
+        return record ?? null;
+    }
+    return Object.freeze({
+        databaseName,
+        async list(sort = defaultDslSort) {
+            const records = await readAll();
+            return records.map(toSummary).sort(compareSummaries(sort));
+        },
+        async count() {
+            const database = await open();
+            const transaction = database.transaction(fileStoreName, 'readonly');
+            const total = await request(transaction.objectStore(fileStoreName).count());
+            await transactionDone(transaction);
+            return total;
+        },
+        get(id) {
+            return readOne(id);
+        },
+        async save(file) {
+            const name = normalizeName(file.name);
+            if (typeof file.source !== 'string') {
+                throw new DslStoreError('invalid-source', 'DSL source must be a string.');
+            }
+            const byteLength = encoder.encode(file.source).byteLength;
+            if (byteLength > maxSourceBytes) {
+                throw new DslStoreError('too-large', `DSL source exceeds ${maxSourceBytes} bytes.`);
+            }
+            const database = await open();
+            const transaction = database.transaction(fileStoreName, 'readwrite');
+            const files = transaction.objectStore(fileStoreName);
+            const existing = await request(files.index(nameIndexName).get(name));
+            if (existing === undefined) {
+                const total = await request(files.count());
+                if (total >= maxFileCount) {
+                    transaction.abort();
+                    throw new DslStoreError('too-many', `The DSL store already holds ${maxFileCount} files.`);
+                }
+            }
+            const timestamp = now().toISOString();
+            const record = {
+                id: existing?.id ?? createId(),
+                name,
+                source: file.source,
+                byteLength,
+                savedAt: existing?.savedAt ?? timestamp,
+                updatedAt: timestamp
+            };
+            await request(files.put(record));
+            await transactionDone(transaction);
+            return record;
+        },
+        async rename(id, nextName) {
+            const name = normalizeName(nextName);
+            const database = await open();
+            const transaction = database.transaction(fileStoreName, 'readwrite');
+            const files = transaction.objectStore(fileStoreName);
+            const existing = await request(files.get(id));
+            if (existing === undefined) {
+                transaction.abort();
+                throw new DslStoreError('not-found', `No DSL file with id ${id}.`);
+            }
+            if (existing.name !== name) {
+                const taken = await request(files.index(nameIndexName).get(name));
+                if (taken !== undefined) {
+                    transaction.abort();
+                    throw new DslStoreError('name-taken', `A DSL file named ${name} already exists.`);
+                }
+            }
+            const record = { ...existing, name, updatedAt: now().toISOString() };
+            await request(files.put(record));
+            await transactionDone(transaction);
+            return record;
+        },
+        async remove(id) {
+            const database = await open();
+            const transaction = database.transaction([fileStoreName, metaStoreName], 'readwrite');
+            await request(transaction.objectStore(fileStoreName).delete(id));
+            const meta = transaction.objectStore(metaStoreName);
+            const pointer = await request(meta.get(lastOpenedKey));
+            if (pointer?.id === id)
+                await request(meta.delete(lastOpenedKey));
+            await transactionDone(transaction);
+        },
+        async clear() {
+            const database = await open();
+            const transaction = database.transaction([fileStoreName, metaStoreName], 'readwrite');
+            await request(transaction.objectStore(fileStoreName).clear());
+            await request(transaction.objectStore(metaStoreName).clear());
+            await transactionDone(transaction);
+        },
+        async lastOpened() {
+            const database = await open();
+            const transaction = database.transaction(metaStoreName, 'readonly');
+            const pointer = await request(transaction.objectStore(metaStoreName).get(lastOpenedKey));
+            await transactionDone(transaction);
+            if (pointer === undefined)
+                return null;
+            return readOne(pointer.id);
+        },
+        async markOpened(id) {
+            const record = await readOne(id);
+            if (record === null)
+                throw new DslStoreError('not-found', `No DSL file with id ${id}.`);
+            const database = await open();
+            const transaction = database.transaction(metaStoreName, 'readwrite');
+            await request(transaction.objectStore(metaStoreName).put({ key: lastOpenedKey, id }));
+            await transactionDone(transaction);
+        },
+        close() {
+            const pending = connection;
+            connection = null;
+            void pending?.then((database) => database.close()).catch(() => undefined);
+        }
+    });
+}
+function defaultCreateId() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === 'function')
+        return crypto.randomUUID();
+    return `dsl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Reads a picked browser file into a record shape the store accepts. */
+export async function readDslFile(file, maxSourceBytes = 1024 * 1024) {
+    if (typeof file?.text !== 'function') {
+        throw new DslStoreError('invalid-source', 'file must be a browser File.');
+    }
+    if (file.size > maxSourceBytes) {
+        throw new DslStoreError('too-large', `DSL file exceeds ${maxSourceBytes} bytes.`);
+    }
+    return { name: file.name, source: await file.text() };
+}

package/dist/lib/events.js

@@ -0,0 +1,20 @@
+export const dslOpenEventName = 'turbowarp-title-menu:dsl-open';
+export const dslReloadEventName = 'turbowarp-title-menu:dsl-reload';
+/**
+ * Announces an opened DSL source on the window.
+ *
+ * The extension also starts a Scratch hat, but a packaged host that embeds this extension may run
+ * its own runtime outside the VM, so the DOM event stays the transport that assumes no Scratch.
+ */
+export function dispatchDslSourceEvent(type, record) {
+    const target = globalThis;
+    if (typeof target.dispatchEvent !== 'function')
+        return;
+    const event = typeof CustomEvent === 'function'
+        ? new CustomEvent(type, { detail: { record } })
+        : new Event(type);
+    if (!('detail' in event)) {
+        Object.defineProperty(event, 'detail', { value: { record } });
+    }
+    target.dispatchEvent(event);
+}

package/dist/lib/locales.js

@@ -0,0 +1,86 @@
+export const titleLocales = Object.freeze({
+    en: {
+        title: 'TurboWarp Title Menu',
+        author: 'Author: Hiroya Kubo',
+        license: 'License: MPL-2.0',
+        website: 'Official Website',
+        close: 'Close'
+    },
+    ja: {
+        title: 'TurboWarp Title Menu',
+        author: '作者: Hiroya Kubo',
+        license: 'ライセンス: MPL-2.0',
+        website: '公式Webサイト',
+        close: '閉じる'
+    }
+});
+export const menuLocales = Object.freeze({
+    en: { files: 'DSL files', reload: 'Reload DSL', about: 'About', close: 'Close' },
+    ja: { files: 'DSLファイル', reload: 'DSLを再読み込み', about: '情報', close: '閉じる' }
+});
+export const dslFilesLocales = Object.freeze({
+    en: {
+        title: 'DSL files',
+        add: 'Add file',
+        open: 'Open',
+        rename: 'Rename',
+        remove: 'Delete',
+        confirmRemove: 'Delete for good?',
+        confirm: 'OK',
+        cancel: 'Cancel',
+        close: 'Close',
+        sortByName: 'Name',
+        sortByDate: 'Updated',
+        sortBySize: 'Size',
+        empty: 'No DSL file is saved yet. Use Add file to store one.'
+    },
+    ja: {
+        title: 'DSLファイル',
+        add: 'ファイルを追加',
+        open: '開く',
+        rename: '名前を変える',
+        remove: '削除',
+        confirmRemove: '本当に削除?',
+        confirm: 'OK',
+        cancel: 'やめる',
+        close: '閉じる',
+        sortByName: '名前',
+        sortByDate: '更新日時',
+        sortBySize: 'サイズ',
+        empty: '保存されたDSLファイルはありません。「ファイルを追加」から保存してください。'
+    }
+});
+const storeErrorMessages = Object.freeze({
+    en: {
+        unavailable: 'Browser storage is unavailable, so DSL files cannot be saved.',
+        'invalid-name': 'That file name cannot be used.',
+        'invalid-source': 'That file could not be read as text.',
+        'name-taken': 'Another DSL file already uses that name.',
+        'too-large': 'That DSL file is too large to store.',
+        'too-many': 'The DSL store is full. Delete a file before adding another.',
+        'not-found': 'That DSL file is no longer stored.',
+        quota: 'Browser storage is full. Delete a DSL file and try again.',
+        failed: 'The DSL storage operation failed.'
+    },
+    ja: {
+        unavailable: 'ブラウザの保存領域が使えないため、DSLファイルを保存できません。',
+        'invalid-name': 'そのファイル名は使えません。',
+        'invalid-source': 'そのファイルをテキストとして読み込めませんでした。',
+        'name-taken': '同じ名前のDSLファイルがすでにあります。',
+        'too-large': 'そのDSLファイルは大きすぎて保存できません。',
+        'too-many': '保存できる数に達しています。どれかを削除してから追加してください。',
+        'not-found': 'そのDSLファイルは保存されていません。',
+        quota: 'ブラウザの保存領域がいっぱいです。DSLファイルを削除してからやり直してください。',
+        failed: 'DSLファイルの操作に失敗しました。'
+    }
+});
+/** Turns a store error code into operator-facing text, falling back to the raw message. */
+export function describeStoreError(locale, error) {
+    const code = error?.code;
+    const messages = storeErrorMessages[locale] ?? storeErrorMessages.en;
+    if (code !== undefined && code in messages)
+        return messages[code];
+    if (error instanceof Error && error.message.length > 0)
+        return error.message;
+    return String(error);
+}

package/dist/lib/title-dialog.js

@@ -0,0 +1,133 @@
+import { ensureRelativeMount, invokeSafely, requireDocument, requireElement } from './dom';
+function requireLocaleText(locales, locale) {
+    const text = locales[locale] ?? locales.en ?? Object.values(locales)[0];
+    if (!text)
+        throw new TypeError('locales must contain at least one locale');
+    for (const key of ['title', 'website', 'close']) {
+        if (typeof text[key] !== 'string' || text[key].length === 0) {
+            throw new TypeError(`locales.${locale}.${key} must be a non-empty string`);
+        }
+    }
+    return text;
+}
+function openWebsite(url) {
+    const opener = globalThis.open;
+    if (typeof opener === 'function') {
+        opener(url, '_blank', 'noopener,noreferrer');
+    }
+    else if (globalThis.location) {
+        globalThis.location.href = url;
+    }
+}
+export function createTitleDialog(options) {
+    const document = requireDocument(options.document ?? globalThis.document);
+    const mount = requireElement(options.mount ?? document.body, 'mount');
+    const locales = options.locales;
+    if (!locales || typeof locales !== 'object')
+        throw new TypeError('locales must be an object');
+    const root = document.createElement('section');
+    const panel = document.createElement('div');
+    const language = document.createElement('button');
+    const close = document.createElement('button');
+    const heading = document.createElement('h1');
+    const meta = document.createElement('p');
+    const website = document.createElement('button');
+    root.setAttribute('data-turbowarp-title-dialog', 'true');
+    root.setAttribute('role', 'dialog');
+    root.setAttribute('aria-modal', 'true');
+    root.style.cssText =
+        'position:absolute;inset:0;z-index:2147483647;display:none;align-items:center;justify-content:center;box-sizing:border-box;background:rgba(0,0,0,.35);font-family:sans-serif;';
+    panel.style.cssText =
+        'position:relative;box-sizing:border-box;width:min(88%,420px);padding:36px 28px 28px;text-align:center;background:#f4fffb;border:1px solid #007d66;border-radius:12px;box-shadow:0 8px 32px rgba(0,0,0,.3);color:#006b58;';
+    language.style.cssText =
+        'position:absolute;top:14px;left:16px;border:0;background:transparent;color:#007d66;font-size:14px;cursor:pointer;';
+    close.style.cssText =
+        'position:absolute;top:12px;right:12px;width:32px;height:32px;border:0;border-radius:50%;background:#007d66;color:#fff;font-size:22px;line-height:28px;cursor:pointer;';
+    heading.style.cssText = 'margin:0 24px 8px;font-size:30px;font-weight:600;line-height:1.15;';
+    meta.style.cssText = 'margin:0 0 22px;font-size:14px;line-height:1.4;';
+    website.style.cssText =
+        'display:inline-flex;align-items:center;justify-content:center;min-height:48px;padding:8px 18px;border:0;border-radius:10px;background:#007d66;color:#fff;font-size:16px;cursor:pointer;';
+    language.type = 'button';
+    close.type = 'button';
+    website.type = 'button';
+    close.textContent = 'x';
+    panel.append(language, close, heading, meta, website);
+    root.appendChild(panel);
+    const restoreMount = ensureRelativeMount(mount);
+    mount.appendChild(root);
+    let locale = options.initialLocale ?? (locales.ja ? 'ja' : Object.keys(locales)[0] ?? 'en');
+    let disposed = false;
+    const render = () => {
+        const text = requireLocaleText(locales, locale);
+        heading.textContent = text.title;
+        meta.textContent = [text.author, text.license].filter(Boolean).join(' / ');
+        meta.hidden = meta.textContent.length === 0;
+        website.textContent = text.website;
+        website.setAttribute('aria-label', text.website);
+        close.setAttribute('aria-label', text.close);
+        close.setAttribute('title', text.close);
+        language.textContent = text.language ?? locale;
+        language.setAttribute('aria-label', text.language ?? locale);
+    };
+    const handleWebsite = () => {
+        if (options.onWebsite)
+            invokeSafely(options.onWebsite, options.onError);
+        else if (options.websiteUrl)
+            openWebsite(options.websiteUrl);
+    };
+    const handleClose = () => {
+        hide();
+        if (options.onClose)
+            invokeSafely(options.onClose, options.onError);
+    };
+    const handleLanguage = () => {
+        const keys = Object.keys(locales);
+        locale = keys[(Math.max(keys.indexOf(locale), 0) + 1) % keys.length] ?? locale;
+        render();
+        if (options.onLocaleChange)
+            invokeSafely(() => options.onLocaleChange?.(locale), options.onError);
+    };
+    website.addEventListener('click', handleWebsite);
+    close.addEventListener('click', handleClose);
+    language.addEventListener('click', handleLanguage);
+    function show(nextLocale = locale) {
+        if (disposed)
+            throw new TypeError('title dialog is disposed');
+        locale = nextLocale;
+        render();
+        root.style.display = 'flex';
+        return locale;
+    }
+    function hide() {
+        if (!disposed)
+            root.style.display = 'none';
+    }
+    function setLocale(nextLocale) {
+        if (disposed)
+            throw new TypeError('title dialog is disposed');
+        locale = nextLocale;
+        render();
+        return locale;
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        website.removeEventListener('click', handleWebsite);
+        close.removeEventListener('click', handleClose);
+        language.removeEventListener('click', handleLanguage);
+        root.remove();
+        restoreMount();
+    }
+    render();
+    return Object.freeze({
+        element: root,
+        get locale() {
+            return locale;
+        },
+        show,
+        hide,
+        setLocale,
+        dispose
+    });
+}