hanzi-chai 0.3.0

package/dist/equivalence.js

@@ -0,0 +1,74 @@
+import { range } from "lodash-es";
+// partition the group into subgroups according to binary equivalence relation
+// using DFS algorithm
+export function partition({ group, relation }) {
+    const visited = new Set();
+    const result = [];
+    for (const v of group) {
+        if (visited.has(v))
+            continue;
+        const subgroup = new Set();
+        const stack = [v];
+        while (stack.length > 0) {
+            const u = stack.pop();
+            visited.add(u);
+            subgroup.add(u);
+            for (const w of group) {
+                if (visited.has(w))
+                    continue;
+                if (relation(u, w))
+                    stack.push(w);
+            }
+        }
+        result.push(subgroup);
+    }
+    return result;
+}
+const isDifferentHand = (p) => {
+    if (p.initial === p.final)
+        return false;
+    return (p.initial < 20 && p.final >= 15) || (p.initial >= 15 && p.final < 20);
+};
+const isSameHand = (p1, p2) => {
+    const numbers = [p1.initial, p1.final, p2.initial, p2.final];
+    return numbers.every((n) => n < 15) || numbers.every((n) => n >= 20);
+};
+const reflect = (n) => {
+    const [col, row] = [Math.floor(n / 5), n % 5];
+    return (6 - col) * 5 + row;
+};
+export const distance = (p) => {
+    if (isDifferentHand(p))
+        return -1;
+    const [x1, y1] = [Math.floor(p.initial / 5), p.initial % 5];
+    const [x2, y2] = [Math.floor(p.final / 5), p.final % 5];
+    return (x1 - x2) ** 2 + (y1 - y2) ** 2;
+};
+export const displacement = (p) => {
+    const [x1, y1] = [Math.floor(p.initial / 5), p.initial % 5];
+    const [x2, y2] = [Math.floor(p.final / 5), p.final % 5];
+    return [x2 - x1, y2 - y1];
+};
+export const 手机五行七列 = {
+    group: new Set(range(35).flatMap((n) => range(35).map((m) => ({ initial: n, final: m })))),
+    relation: (p1, p2) => {
+        // 异指连击当量相同
+        if (isDifferentHand(p1) && isDifferentHand(p2))
+            return true;
+        // 同键连击当量相同
+        if (p1.initial === p1.final && p2.initial === p2.final)
+            return true;
+        // 时间反演
+        if (p1.initial === p2.final && p1.final === p2.initial)
+            return true;
+        // 空间镜像
+        if (reflect(p1.initial) === p2.initial && reflect(p1.final) === p2.final)
+            return true;
+        // 空间平移（同手）
+        const [dx1, dy1] = displacement(p1);
+        const [dx2, dy2] = displacement(p2);
+        if (isSameHand(p1, p2) && dx1 === dx2 && dy1 === dy2)
+            return true;
+        return false;
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+export * from "./affine.js";
+export * from "./element.js";
+export * from "./bezier.js";
+export * from "./topology.js";
+export * from "./data.js";
+export * from "./config.js";
+export * from "./classifier.js";
+export * from "./repertoire.js";
+export * from "./degenerator.js";
+export * from "./selector.js";
+export * from "./assembly.js";
+export * from "./component.js";
+export * from "./compound.js";
+export * from "./utils.js";
+export * from "./mathjs.js";
+export * from "./transformer.js";
+import { PrimitiveCharacter, PrimitiveRepertoire, Repertoire } from "./data.js";
+import { Dictionary, Frequency } from "./utils.js";
+import { Config } from "./config.js";
+import { AnalysisConfig } from "./repertoire.js";
+export interface Item {
+    id: number;
+    name: string;
+    price: number;
+}
+interface Model {
+    unicode: number;
+    tygf: 0 | 1 | 2 | 3;
+    gb2312: 0 | 1 | 2;
+    readings: string;
+    glyphs: string;
+    name: string | null;
+    gf0014_id: number | null;
+    gf3001_id: number | null;
+    ambiguous: 0 | 1;
+}
+export declare function fromModel(model: Model): PrimitiveCharacter;
+export declare function getPrimitveRepertoire(): PrimitiveRepertoire;
+export declare function getDictionary(): Dictionary;
+export declare function getFrequency(): Frequency;
+export declare function getRepertoire(config: Config): Repertoire;
+export declare function getCharacters(config: Config, repertoire: Repertoire): string[];
+export declare function getAnalysisConfig(config: Config, repertoire: Repertoire): AnalysisConfig;
+export declare function getAnalysisResult(config: Config, repertoire: Repertoire): import("./repertoire.js").AnalysisResult;
+export declare function getAssemblyResult(config: Config, repertoire: Repertoire): void;

package/dist/index.js

@@ -0,0 +1,126 @@
+export * from "./affine.js";
+export * from "./element.js";
+export * from "./bezier.js";
+export * from "./topology.js";
+export * from "./data.js";
+export * from "./config.js";
+export * from "./classifier.js";
+export * from "./repertoire.js";
+export * from "./degenerator.js";
+export * from "./selector.js";
+export * from "./assembly.js";
+export * from "./component.js";
+export * from "./compound.js";
+export * from "./utils.js";
+export * from "./mathjs.js";
+export * from "./transformer.js";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Pako from "pako";
+import { characterSetFilters, listToObject } from "./utils.js";
+import { analysis, determine } from "./repertoire.js";
+import { 应用变换器 } from "./transformer.js";
+import { assemble } from "./assembly.js";
+// ESM 中模拟 __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const codeToChar = (code) => String.fromCodePoint(code);
+const glyphForward = (c) => {
+    if (c.type === "basic_component") {
+        return c;
+    }
+    else if (c.type === "derived_component" || c.type === "identity") {
+        return { ...c, source: codeToChar(c.source) };
+    }
+    else {
+        return { ...c, operandList: c.operandList.map(codeToChar) };
+    }
+};
+export function fromModel(model) {
+    return {
+        ...model,
+        readings: JSON.parse(model.readings),
+        glyphs: JSON.parse(model.glyphs).map(glyphForward),
+        ambiguous: model.ambiguous === 1,
+    };
+}
+export function getPrimitveRepertoire() {
+    const filePath = path.join(__dirname, "data", "repertoire.json.deflate");
+    const compressed = readFileSync(filePath);
+    const decompressed = Pako.inflate(compressed, { to: "string" });
+    const raw = JSON.parse(decompressed).map(fromModel);
+    const primitiveRepertoire = listToObject(raw);
+    return primitiveRepertoire;
+}
+export function getDictionary() {
+    const filePath = path.join(__dirname, "data", "dictionary.txt");
+    const raw = readFileSync(filePath, "utf-8");
+    return raw.trim().split("\n").map((line) => {
+        const [key, value] = line.split("\t");
+        return [key, value];
+    });
+}
+export function getFrequency() {
+    const filePath = path.join(__dirname, "data", "frequency.txt");
+    const raw = readFileSync(filePath, "utf-8");
+    return Object.fromEntries(raw.trim().split("\n").map((line) => {
+        const [char, freq] = line.split("\t");
+        return [char, Number(freq)];
+    }));
+}
+export function getRepertoire(config) {
+    const primitiveRepertoire = getPrimitveRepertoire();
+    const userRepertoire = config.data?.repertoire ?? {};
+    const allRepertoire = { ...primitiveRepertoire, ...userRepertoire };
+    const customGlyph = config.data?.glyph_customization ?? {};
+    const customReadings = config.data?.reading_customization ?? {};
+    const tags = config.data?.tags ?? [];
+    let determined = determine(allRepertoire, customGlyph, customReadings, tags);
+    const transformers = config.data?.transformers ?? [];
+    for (const transformer of transformers) {
+        determined = 应用变换器(determined, transformer);
+    }
+    return determined;
+}
+export function getCharacters(config, repertoire) {
+    const characterSet = config.data?.character_set ?? "minimal";
+    const filter = characterSetFilters[characterSet];
+    const characters = Object.entries(repertoire)
+        .filter(([k, v]) => filter(k, v))
+        .map(([k]) => k);
+    return characters;
+}
+export function getAnalysisConfig(config, repertoire) {
+    const mapping = config.form.mapping;
+    const mappingSpace = config.form.mapping_space ?? {};
+    const optionalRoots = new Set();
+    for (const [key, value] of Object.entries(mappingSpace)) {
+        if (value.some((x) => x.value == null) || mapping[key] === undefined) {
+            optionalRoots.add(key);
+        }
+    }
+    const analysis = config.analysis ?? {};
+    const roots = new Map(Object.entries(mapping).filter(([x]) => repertoire[x]));
+    return {
+        analysis,
+        roots,
+        optionalRoots,
+    };
+}
+export function getAnalysisResult(config, repertoire) {
+    const analysisConfig = getAnalysisConfig(config, repertoire);
+    const characters = getCharacters(config, repertoire);
+    return analysis(repertoire, analysisConfig, characters);
+}
+export function getAssemblyResult(config, repertoire) {
+    const characters = getCharacters(config, repertoire);
+    const analysisResult = getAnalysisResult(config, repertoire);
+    const assembleConfig = {
+        algebra: config.algebra ?? {},
+        encoder: config.encoder ?? {},
+        keyboard: config.form ?? {},
+        priority: config.encoder?.priority_short_codes ?? [],
+    };
+    assemble(repertoire, assembleConfig, characters, getDictionary(), new Map(Object.entries(getFrequency())), analysisResult, {});
+}