@kecan0406/aninames 0.0.0-stage → 0.2.0

package/lib/client/source.js

@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { USER_AGENT } from "../model.js";
+import { manifestPaths, parsePath, readManifest, TABLES } from "./format.js";
+export class Missing extends Error {
+}
+const revalidators = new WeakMap();
+function checked(path) {
+    if (!parsePath(path))
+        throw new Error(`aninames: ${JSON.stringify(path)} is not a chunk file name`);
+    return path;
+}
+export function httpSource(base, options = {}) {
+    const root = base.endsWith('/') ? base : `${base}/`;
+    const request = async (path, signal, extra = {}) => {
+        const url = new URL(path, root);
+        const response = await (options.fetch ?? fetch)(url, {
+            headers: { 'user-agent': USER_AGENT, ...options.headers, ...extra },
+            ...(signal ? { signal } : {}),
+        });
+        if (response.status === 404)
+            throw new Missing(`aninames: ${url} is not there (404)`);
+        if (!response.ok && response.status !== 304)
+            throw new Error(`aninames: ${url} answered ${response.status}`);
+        return response;
+    };
+    const source = {
+        manifest: async (signal) => (await request('manifest.json', signal)).text(),
+        file: async (path, signal) => new Uint8Array(await (await request(checked(path), signal)).arrayBuffer()),
+    };
+    revalidators.set(source, async ({ etag, modified }, signal) => {
+        const response = await request('manifest.json', signal, {
+            ...(etag ? { 'if-none-match': etag } : {}),
+            ...(modified ? { 'if-modified-since': modified } : {}),
+        });
+        if (response.status === 304)
+            return undefined;
+        return {
+            text: await response.text(),
+            etag: response.headers.get('etag'),
+            modified: response.headers.get('last-modified'),
+        };
+    });
+    return source;
+}
+const missing = (error) => error?.code === 'ENOENT';
+export function fileSource(dir) {
+    return {
+        async manifest(signal) {
+            try {
+                return await readFile(join(dir, 'manifest.json'), { encoding: 'utf8', ...(signal ? { signal } : {}) });
+            }
+            catch (error) {
+                if (missing(error))
+                    throw new Error(`aninames: ${join(dir, 'manifest.json')} is missing; run mise run chunk`);
+                throw error;
+            }
+        },
+        async file(path, signal) {
+            try {
+                return new Uint8Array(await readFile(join(dir, checked(path)), signal ? { signal } : {}));
+            }
+            catch (error) {
+                if (missing(error))
+                    throw new Missing(`aninames: ${join(dir, path)} is missing`);
+                throw error;
+            }
+        },
+    };
+}
+function cachedOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const { text, etag, modified, checked } = value;
+    if (typeof text !== 'string' || typeof checked !== 'number')
+        return undefined;
+    return {
+        text,
+        checked,
+        etag: typeof etag === 'string' ? etag : null,
+        modified: typeof modified === 'string' ? modified : null,
+    };
+}
+async function put(path, data) {
+    const part = `${path}.${randomUUID()}.part`;
+    try {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(part, data);
+        await rename(part, path);
+    }
+    catch {
+        await rm(part, { force: true });
+    }
+}
+async function prune(dir, text) {
+    const named = manifestPaths(readManifest(text));
+    for (const layer of await readdir(dir).catch(() => [])) {
+        for (const table of TABLES) {
+            const folder = join(dir, layer, table);
+            for (const file of await readdir(folder).catch(() => [])) {
+                const path = `${layer}/${table}/${file}`;
+                if (parsePath(path) && !named.has(path))
+                    await rm(join(folder, file), { force: true });
+            }
+        }
+    }
+}
+export function cachedSource(source, dir, options = {}) {
+    const maxAge = options.maxAge ?? 86_400_000;
+    const state = join(dir, 'manifest.cache.json');
+    let stale = false;
+    const read = async () => {
+        try {
+            return cachedOf(JSON.parse(await readFile(state, 'utf8')));
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const fetchFresh = async (cached, signal) => {
+        const revalidate = revalidators.get(source);
+        if (revalidate)
+            return revalidate(cached ?? { etag: null, modified: null }, signal);
+        return { text: await source.manifest(signal), etag: null, modified: null };
+    };
+    return {
+        async manifest(signal) {
+            const cached = await read();
+            if (cached && !stale && Date.now() - cached.checked < maxAge)
+                return cached.text;
+            let fresh;
+            try {
+                fresh = await fetchFresh(cached, signal);
+            }
+            catch (error) {
+                if (cached && !signal?.aborted)
+                    return cached.text;
+                throw error;
+            }
+            stale = false;
+            if (!fresh) {
+                if (!cached)
+                    throw new Error('aninames: the server answered 304 to a manifest request without validators');
+                await put(state, JSON.stringify({ ...cached, checked: Date.now() }));
+                return cached.text;
+            }
+            readManifest(fresh.text);
+            await put(state, JSON.stringify({ ...fresh, checked: Date.now() }));
+            if (fresh.text !== cached?.text)
+                await prune(dir, fresh.text);
+            return fresh.text;
+        },
+        async file(path, signal) {
+            const target = join(dir, checked(path));
+            try {
+                return new Uint8Array(await readFile(target));
+            }
+            catch (error) {
+                if (!missing(error))
+                    throw error;
+            }
+            let bytes;
+            try {
+                bytes = await source.file(path, signal);
+            }
+            catch (error) {
+                if (error instanceof Missing)
+                    stale = true;
+                throw error;
+            }
+            const hash = createHash('sha256').update(bytes).digest('hex');
+            if (!hash.startsWith(parsePath(path)?.hash ?? '-')) {
+                throw new Error(`aninames: ${path} arrived with other contents (sha256 ${hash.slice(0, 12)})`);
+            }
+            await put(target, bytes);
+            return bytes;
+        },
+    };
+}

package/lib/match.d.ts

@@ -0,0 +1,9 @@
+import type { NameKind } from './model.ts';
+export declare const TOP = "\uDBFF\uDFFF";
+export declare function weightOf(row: {
+    kind: NameKind;
+    variant: number;
+    support: number;
+}): number;
+export declare function typing(q: string): [string, string][];
+export declare function swapLayout(query: string): string | undefined;

package/lib/match.js

@@ -0,0 +1,58 @@
+import { convertHangulToQwerty, convertQwertyToHangul } from 'es-hangul';
+export const TOP = '\u{10FFFF}';
+const NAME_WEIGHT = {
+    main: 1,
+    official: 1,
+    reading: 1,
+    synonym: 0.95,
+    short: 0.95,
+    redirect: 0.92,
+    section: 0.6,
+    generated: 0.85,
+};
+const WEAK = new Set(['synonym', 'short', 'redirect', 'section']);
+export function weightOf(row) {
+    return NAME_WEIGHT[row.kind] * (row.variant ? 0.9 : 1) * (row.support <= 1 && WEAK.has(row.kind) ? 0.93 : 1);
+}
+const INITIAL_JAMO = 'ㄱㄲㄴㄷㄸㄹㅁㅂㅃㅅㅆㅇㅈㅉㅊㅋㅌㅍㅎ';
+export function typing(q) {
+    const ranges = [[q, `${q}${TOP}`]];
+    const chars = [...q];
+    const last = chars.at(-1) ?? '';
+    const head = chars.slice(0, -1).join('');
+    const code = (last.codePointAt(0) ?? 0) - 0xac00;
+    if (code >= 0 && code < 11172 && code % 28 === 0) {
+        ranges.push([
+            `${head}${String.fromCodePoint(0xac00 + code + 1)}`,
+            `${head}${String.fromCodePoint(0xac00 + code + 27)}${TOP}`,
+        ]);
+    }
+    const conjoined = (last.codePointAt(0) ?? 0) - 0x1100;
+    const initial = conjoined >= 0 && conjoined < 19 ? conjoined : INITIAL_JAMO.indexOf(last);
+    if (initial >= 0 && head) {
+        ranges.push([
+            `${head}${String.fromCodePoint(0xac00 + initial * 588)}`,
+            `${head}${String.fromCodePoint(0xac00 + initial * 588 + 587)}${TOP}`,
+        ]);
+    }
+    const kana = /^([\p{Script=Hiragana}\p{Script=Katakana}ー]+)[a-z]+$/u.exec(q)?.[1];
+    if (kana)
+        ranges.push([kana, `${kana}${TOP}`]);
+    return ranges;
+}
+export function swapLayout(query) {
+    const text = query.trim();
+    try {
+        if (/[a-z]/i.test(text) && !/[\p{Script=Hangul}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u.test(text)) {
+            const hangul = text.replace(/[a-z]+/gi, (run) => convertQwertyToHangul(run));
+            return /[ㄱ-ㅎㅏ-ㅣ]/.test(hangul) || !/\p{Script=Hangul}/u.test(hangul) ? undefined : hangul;
+        }
+        if (/\p{Script=Hangul}/u.test(text) && !/[a-z\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/iu.test(text)) {
+            return text.replace(/[\p{Script=Hangul}]+/gu, (run) => convertHangulToQwerty(run)).toLowerCase();
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}

package/lib/model.d.ts

@@ -0,0 +1,34 @@
+export type Kind = 'work' | 'character';
+export type Layer = 'core' | 'kowiki' | 'unlicensed';
+export declare const LAYERS: readonly Layer[];
+export declare const USER_AGENT = "aninames/0.1 (+https://github.com/kecan0406/aninames)";
+export type NameKind = 'main' | 'official' | 'synonym' | 'short' | 'reading' | 'redirect' | 'section' | 'generated';
+export type Namespace = 'wikidata' | 'mal' | 'anilist' | 'anidb' | 'kitsu' | 'ann' | 'animeplanet' | 'anisearch' | 'livechart' | 'simkl' | 'animecountdown' | 'tmdb' | 'vndb' | 'bangumi' | 'danbooru' | 'kowiki' | 'anissia';
+export type Ref = `${Namespace}:${string}`;
+export interface Name {
+    text: string;
+    lang?: string;
+    kind: NameKind;
+}
+export interface Entry {
+    id: Ref;
+    kind?: Kind;
+    attach?: boolean;
+    refs?: Ref[];
+    names: Name[];
+    works?: Ref[];
+    related?: Ref[];
+    link?: string[];
+    rank?: number;
+    adult?: boolean;
+    type?: string;
+    year?: number;
+}
+export interface Source {
+    name: string;
+    layer: Layer;
+    license: string;
+    fetch(raw: string): Promise<void>;
+    stage(raw: string): AsyncIterable<Entry> | Iterable<Entry>;
+}
+export declare function ref(ns: Namespace, id: string | number): Ref;

package/lib/model.js

@@ -0,0 +1,5 @@
+export const LAYERS = ['core', 'kowiki', 'unlicensed'];
+export const USER_AGENT = 'aninames/0.1 (+https://github.com/kecan0406/aninames)';
+export function ref(ns, id) {
+    return `${ns}:${id}`;
+}

package/lib/text.d.ts

@@ -0,0 +1,24 @@
+export declare function toHiragana(text: string): string;
+export declare function isKana(text: string): boolean;
+export declare function hasHangul(text: string): boolean;
+export declare function hasKanji(text: string): boolean;
+export declare function kanaToRomaji(kana: string): string;
+export declare function hangulToLatin(text: string): string;
+export declare function foldLatin(text: string): string;
+export declare function soundKeys(text: string): string[];
+export declare function flat(text: string): string;
+export declare function latinKey(text: string): string;
+export declare function partKey(token: string): string;
+export declare function qualifiers(text: string): {
+    base: string;
+    quals: string[];
+};
+type HangulStyle = 'standard' | 'fan' | 'fan-long';
+export declare function kanaToHangul(kana: string, style: HangulStyle): string;
+export declare function initials(text: string): string;
+export declare function editDistance(a: string, b: string, limit: number): number;
+export declare function hangulForms(kana: string): {
+    text: string;
+    preferred: boolean;
+}[];
+export {};