hanzi-chai 0.3.0

package/dist/affine.d.ts

@@ -0,0 +1,8 @@
+import type { Compound, SVGGlyphWithBox } from "./data.js";
+/**
+ * 给定复合体数据和各部分渲染后的 SVG 图形，返回合并后的 SVG 图形
+ * @param compound - 复合体数据
+ * @param glyphList - 各部分渲染后的 SVG 图形
+ * @returns 合并后的 SVG 图形
+ */
+export declare function affineMerge(compound: Compound, glyphList: SVGGlyphWithBox[]): SVGGlyphWithBox;

package/dist/affine.js

@@ -0,0 +1,153 @@
+import { add } from "./mathjs.js";
+import { cloneDeep } from "lodash-es";
+class Affine {
+    xscale;
+    yscale;
+    translate;
+    constructor(xscale, yscale, translate = [0, 0]) {
+        this.xscale = xscale;
+        this.yscale = yscale;
+        this.translate = translate;
+    }
+    transformDraw(draw) {
+        const next = cloneDeep(draw);
+        switch (next.command) {
+            case "h":
+                next.parameterList[0] *= this.xscale;
+                break;
+            case "v":
+                next.parameterList[0] *= this.yscale;
+                break;
+            case "c":
+            case "z":
+                for (const index of [0, 2, 4]) {
+                    next.parameterList[index] *= this.xscale;
+                    next.parameterList[index + 1] *= this.yscale;
+                }
+                break;
+        }
+        return next;
+    }
+    transformSVGStroke(stroke) {
+        const [x, y] = stroke.start;
+        const start = add([x * this.xscale, y * this.yscale], this.translate);
+        const next = {
+            ...stroke,
+            start,
+            curveList: stroke.curveList.map((c) => this.transformDraw(c)),
+        };
+        return next;
+    }
+    transformSVGGlyph(glyph) {
+        return glyph.map((x) => this.transformSVGStroke(x));
+    }
+}
+const id = new Affine(1, 1);
+const left = new Affine(0.5, 1);
+const right = new Affine(0.5, 1, [50, 0]);
+const top = new Affine(1, 0.5);
+const bottom = new Affine(1, 0.5, [0, 50]);
+const leftThird = new Affine(0.33, 1);
+const centerThird = new Affine(0.33, 1, [33, 0]);
+const rightThird = new Affine(0.33, 1, [66, 0]);
+const topThird = new Affine(1, 0.33);
+const middleThird = new Affine(1, 0.33, [0, 33]);
+const bottomThird = new Affine(1, 0.33, [0, 66]);
+const affineMap = {
+    "⿰": [left, right],
+    "⿱": [top, bottom],
+    "⿲": [leftThird, centerThird, rightThird],
+    "⿳": [topThird, middleThird, bottomThird],
+    "⿴": [id, new Affine(0.5, 0.5, [25, 25])],
+    "⿵": [id, new Affine(0.5, 0.5, [25, 40])],
+    "⿶": [id, new Affine(0.5, 0.5, [25, 10])],
+    "⿷": [id, new Affine(0.5, 0.5, [40, 25])],
+    "⿸": [id, new Affine(0.5, 0.5, [40, 40])],
+    "⿹": [id, new Affine(0.5, 0.5, [10, 40])],
+    "⿺": [id, new Affine(0.5, 0.5, [40, 10])],
+    "⿼": [id, new Affine(0.5, 0.5, [10, 25])],
+    "⿽": [id, new Affine(0.5, 0.5, [10, 10])],
+    "⿻": [id, id],
+    "⿾": [id],
+    "⿿": [id],
+};
+/**
+ * 给定复合体数据和各部分渲染后的 SVG 图形，返回合并后的 SVG 图形
+ * @param compound - 复合体数据
+ * @param glyphList - 各部分渲染后的 SVG 图形
+ * @returns 合并后的 SVG 图形
+ */
+export function affineMerge(compound, glyphList) {
+    const { operator, order, parameters } = compound;
+    const transformedGlyphs = [];
+    const boundingBox = { x: [0, 100], y: [0, 100] };
+    if (["⿰", "⿲", "⿱", "⿳"].includes(operator)) {
+        // 上下、上中下、左右、左中右，直接拼接
+        let mainAxisOffset = 0;
+        const isLR = ["⿰", "⿲"].includes(operator);
+        for (const [index, { strokes, box }] of glyphList.entries()) {
+            const mainAxisLength = isLR ? box.x[1] - box.x[0] : box.y[1] - box.y[0];
+            if (index === 0) {
+                transformedGlyphs.push(structuredClone(strokes));
+                boundingBox.x = structuredClone(box.x);
+                boundingBox.y = structuredClone(box.y);
+                mainAxisOffset = isLR ? box.x[1] : box.y[1];
+                continue;
+            }
+            let gap = 20;
+            if (index === 1 && parameters?.gap2 !== undefined) {
+                gap = parameters.gap2;
+            }
+            else if (index === 2 && parameters?.gap3 !== undefined) {
+                gap = parameters.gap3;
+            }
+            mainAxisOffset += gap;
+            const increase = gap + mainAxisLength;
+            let affine;
+            if (isLR) {
+                affine = new Affine(1, 1, [mainAxisOffset - box.x[0], 0]);
+                boundingBox.x[1] += increase;
+                boundingBox.y[0] = Math.min(boundingBox.y[0], box.y[0]);
+                boundingBox.y[1] = Math.max(boundingBox.y[1], box.y[1]);
+            }
+            else {
+                affine = new Affine(1, 1, [0, mainAxisOffset - box.y[0]]);
+                boundingBox.y[1] += increase;
+                boundingBox.x[0] = Math.min(boundingBox.x[0], box.x[0]);
+                boundingBox.x[1] = Math.max(boundingBox.x[1], box.x[1]);
+            }
+            transformedGlyphs.push(affine.transformSVGGlyph(strokes));
+            mainAxisOffset += mainAxisLength;
+        }
+    }
+    else {
+        // 包围或结构，暂时还没有优化拼接的算法，用原来的仿射变换算法
+        for (const [index, affine] of affineMap[operator].entries()) {
+            const transformed = affine.transformSVGGlyph(glyphList[index].strokes);
+            transformedGlyphs.push(transformed);
+        }
+    }
+    const result = [];
+    if (order === undefined) {
+        result.push(...transformedGlyphs.flat());
+    }
+    else {
+        for (const { index, strokes } of order) {
+            const glyph = transformedGlyphs[index];
+            if (glyph === undefined)
+                continue;
+            if (strokes === 0) {
+                result.push(...glyph);
+            }
+            else {
+                result.push(...glyph.slice(0, strokes));
+                transformedGlyphs[index] = glyph.slice(strokes);
+            }
+        }
+    }
+    const merged = {
+        strokes: result,
+        box: boundingBox,
+    };
+    return merged;
+}

package/dist/assembly.d.ts

@@ -0,0 +1,63 @@
+import { type Algebra, type EncoderConfig, type Keyboard } from "./config.js";
+import type { ComponentAnalysis } from "./component.js";
+import type { CompoundAnalysis } from "./compound.js";
+import type { Repertoire } from "./data.js";
+import type { AnalysisResult } from "./repertoire.js";
+import type { Dictionary, CustomElementMap } from "./utils.js";
+export declare const getPriorityMap: (priorityShortCodes: [string, string, number][]) => Map<string, number>;
+/**
+ * 代表了一个有字音、有字形的汉字的中间结果
+ * 由拆分结果 [`ComponentResult`](#componentresult) 或 [`CompoundResult`](#compoundresult) 与字音组成
+ */
+export type CharacterResult = (ComponentAnalysis | CompoundAnalysis) & {
+    char: string;
+    pinyin: string;
+    frequency: number;
+    custom: Record<string, string[]>;
+};
+export type IndexedElement = string | {
+    element: string;
+    index: number;
+};
+export interface Assembly {
+    name: string;
+    pinyin_list: string[];
+    sequence: IndexedElement[];
+    frequency: number;
+    level?: number;
+}
+export type AssemblyResult = Assembly[];
+interface AssembleConfig {
+    encoder: EncoderConfig;
+    keyboard: Keyboard;
+    algebra: Algebra;
+    priority: [string, string, number][];
+}
+/**
+ * 给定一个拆分结果，返回所有可能的编码
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ * @param characters - 需要编码的汉字列表
+ * @param analysisResult - 分析结果
+ *
+ * @returns 组装结果
+ */
+export declare const assemble: (repertoire: Repertoire, config: AssembleConfig, characters: string[], dictionary: Dictionary, adaptedFrequency: Map<string, number>, analysisResult: AnalysisResult, customElements: Record<string, CustomElementMap>) => AssemblyResult;
+export declare const stringifySequence: (result: AssemblyResult) => {
+    sequence: string;
+    name: string;
+    pinyin_list: string[];
+    frequency: number;
+    level?: number;
+}[];
+export declare const summarize: (elements: (IndexedElement | undefined)[]) => string;
+export interface DictEntry {
+    name: string;
+    full: string;
+    full_rank: number;
+    short: string;
+    short_rank: number;
+}
+export type EncodeResult = DictEntry[];
+export {};

package/dist/assembly.js

@@ -0,0 +1,286 @@
+import { isMerge, } from "./config.js";
+import { algebraCache, findElement } from "./element.js";
+export const getPriorityMap = (priorityShortCodes) => {
+    return new Map(priorityShortCodes.map(([word, pinyin_list, level]) => {
+        const hash = `${word}-${pinyin_list}`;
+        return [hash, level];
+    }));
+};
+const table = {
+    是: (t, v) => t === v,
+    不是: (t, v) => t !== v,
+    匹配: (t, v) => t !== undefined && new RegExp(v).test(t),
+    不匹配: (t, v) => t !== undefined && !new RegExp(v).test(t),
+    编码匹配: (t, v, m) => t !== undefined && new RegExp(v).test(m[t]),
+    编码不匹配: (t, v, m) => t !== undefined && !new RegExp(v).test(m[t]),
+    存在: (t) => t !== undefined,
+    不存在: (t) => t === undefined,
+};
+/**
+ * 给定一个条件，判断是否满足
+ *
+ * @param condition - 条件
+ * @param result - 中间结果
+ * @param config - 配置
+ * @param extra - 额外信息
+ * @param totalMapping - 映射
+ */
+const satisfy = (condition, result, config, extra, totalMapping) => {
+    const { object, operator } = condition;
+    const target = findElement(object, result, config, extra);
+    const fn = table[operator];
+    if ("value" in condition) {
+        return fn(target, condition.value, totalMapping);
+    }
+    return fn(target, null, totalMapping);
+};
+const compile = (keyboard, encoder, algebra) => {
+    const { mapping } = keyboard;
+    const alphabet = keyboard.alphabet ?? "";
+    const totalMapping = {};
+    return (result, data, extra) => {
+        let node = "s0";
+        const codes = [];
+        while (node) {
+            if (node.startsWith("s")) {
+                const source = encoder.sources[node];
+                const { object, next, index } = source;
+                if (node !== "s0") {
+                    const element = findElement(object, result, algebra, extra);
+                    // 检查元素或键位是否有效
+                    if (element === undefined) {
+                        node = next;
+                        continue;
+                    }
+                    // 如果是固定编码，直接加入
+                    if (element.length === 1 && alphabet.includes(element)) {
+                        codes.push(element);
+                        node = next;
+                        continue;
+                    }
+                    let mapped = mapping[element];
+                    let groupedElement = element;
+                    if (mapped === undefined) {
+                        node = next;
+                        continue;
+                    }
+                    while (isMerge(mapped)) {
+                        groupedElement = mapped.element;
+                        mapped = mapping[mapped.element];
+                    }
+                    if (index === undefined) {
+                        // 如果没有定义指标，就是全取
+                        for (const [index, key] of Array.from(mapped).entries()) {
+                            codes.push(
+                            // typeof key === "string"
+                            //   ? { element: groupedElement, index }
+                            //   : key,
+                            { element: groupedElement, index });
+                        }
+                    }
+                    else {
+                        // 检查指标是否有效
+                        const key = mapped[index];
+                        if (key !== undefined) {
+                            codes.push(
+                            // typeof key === "string"
+                            //   ? { element: groupedElement, index }
+                            //   : key,
+                            { element: groupedElement, index });
+                        }
+                    }
+                }
+                node = next;
+            }
+            else {
+                const condition = encoder.conditions[node];
+                if (satisfy(condition, result, algebra, extra, totalMapping)) {
+                    node = condition.positive;
+                }
+                else {
+                    node = condition.negative;
+                }
+            }
+        }
+        return codes.slice(0, encoder.max_length ?? codes.length);
+    };
+};
+const signedIndex = (elements, index) => {
+    const order = index.codePointAt(0) - "a".codePointAt(0);
+    const signedOrder = order < 13 ? order : order - 26;
+    return elements.at(signedOrder);
+};
+const gather = (totalElements, rules) => {
+    const result = [];
+    let matched = false;
+    for (const rule of rules) {
+        if ("length_equal" in rule) {
+            matched = totalElements.length === rule.length_equal;
+        }
+        else if ("length_in_range" in rule) {
+            matched =
+                totalElements.length >= rule.length_in_range[0] &&
+                    totalElements.length <= rule.length_in_range[1];
+        }
+        if (matched) {
+            const tokens = Array.from(rule.formula);
+            for (let i = 0; i < tokens.length; i = i + 2) {
+                const charIndex = tokens[i].toLowerCase();
+                const elementIndex = tokens[i + 1];
+                const elements = signedIndex(totalElements, charIndex);
+                if (elements === undefined)
+                    continue;
+                const element = signedIndex(elements, elementIndex);
+                if (element === undefined)
+                    continue;
+                result.push(element);
+            }
+            break;
+        }
+    }
+    if (matched)
+        return result;
+};
+/**
+ * 给定一个拆分结果，返回所有可能的编码
+ *
+ * @param repertoire - 字符集
+ * @param config - 配置
+ * @param characters - 需要编码的汉字列表
+ * @param analysisResult - 分析结果
+ *
+ * @returns 组装结果
+ */
+export const assemble = (repertoire, config, characters, dictionary, adaptedFrequency, analysisResult, customElements) => {
+    const { customized, compoundResults } = analysisResult;
+    const extra = { rootSequence: analysisResult.rootSequence };
+    const func = compile(config.keyboard, config.encoder, config.algebra);
+    const result = [];
+    algebraCache.clear();
+    const characterCache = new Map();
+    const customLookup = (character) => Object.fromEntries(Object.entries(customElements).map(([name, map]) => {
+        return [name, (map[character] ?? []).map((x) => `${name}-${x}`)];
+    }));
+    // 一字词
+    for (const character of characters) {
+        const frequency = adaptedFrequency.get(character) ?? 0;
+        // TODO: 支持多个拆分结果
+        const shapeInfo = customized.get(character) || compoundResults.get(character);
+        if (shapeInfo === undefined)
+            continue;
+        const final = [];
+        if (character in repertoire === false)
+            continue;
+        const readings = [...repertoire[character].readings];
+        if (readings.length === 0) {
+            readings.push({ pinyin: "", importance: 100 });
+        }
+        for (const reading of readings) {
+            const result = {
+                char: character,
+                pinyin: reading.pinyin,
+                frequency: Math.round(frequency * (reading.importance / 100)),
+                ...shapeInfo,
+                custom: customLookup(character),
+            };
+            const elements = func(result, repertoire, extra);
+            characterCache.set(`${character}:${reading.pinyin}`, elements);
+            const summary = summarize(elements);
+            let isDuplicated = false;
+            for (const previous of final) {
+                if (summarize(previous.sequence) === summary) {
+                    previous.frequency += result.frequency;
+                    previous.pinyin_list.push(reading.pinyin);
+                    isDuplicated = true;
+                    break;
+                }
+            }
+            if (!isDuplicated) {
+                final.push({
+                    name: character,
+                    sequence: elements,
+                    frequency: result.frequency,
+                    pinyin_list: [reading.pinyin],
+                });
+            }
+        }
+        result.push(...final);
+    }
+    const rules = config.encoder.rules;
+    if (!rules)
+        return result;
+    const knownWords = new Set();
+    // 多字词
+    for (const [word, pinyin] of dictionary) {
+        const frequency = adaptedFrequency.get(word) ?? 0;
+        const characters = Array.from(word);
+        const syllables = pinyin.split(" ");
+        let valid = true;
+        const totalElements = [];
+        for (const [i, character] of characters.entries()) {
+            const pinyin = syllables[i];
+            // 复用已有的编码
+            const hash = `${character}:${pinyin}`;
+            let elements = characterCache.get(hash);
+            if (elements !== undefined) {
+                totalElements.push(elements);
+                continue;
+            }
+            const shapeInfo = customized.get(character) || compoundResults.get(character);
+            if (shapeInfo === undefined) {
+                valid = false;
+                break;
+            }
+            const result = {
+                char: character,
+                pinyin,
+                frequency,
+                ...shapeInfo,
+                custom: customLookup(character),
+            };
+            elements = func(result, repertoire, extra);
+            totalElements.push(elements);
+        }
+        if (!valid)
+            continue;
+        const wordElements = gather(totalElements, rules);
+        if (wordElements === undefined)
+            continue;
+        const hash = `${word}:${summarize(wordElements)}`;
+        if (knownWords.has(hash))
+            continue;
+        // 多音的多字词数量很少，所以不再计算分频比例，直接设为 100
+        result.push({
+            name: word,
+            sequence: wordElements,
+            frequency,
+            pinyin_list: [pinyin],
+        });
+        knownWords.add(hash);
+    }
+    const priorityMap = getPriorityMap(config.priority);
+    return result.map((x) => {
+        const hash = `${x.name}-${x.pinyin_list.join(",")}`;
+        const level = priorityMap.get(hash);
+        return level !== undefined ? { ...x, level } : x;
+    });
+};
+export const stringifySequence = (result) => {
+    return result.map((x) => {
+        return { ...x, sequence: summarize(x.sequence) };
+    });
+};
+export const summarize = (elements) => {
+    return elements
+        .map((x) => {
+        if (x === undefined)
+            return "ε";
+        if (typeof x === "string")
+            return x;
+        if (x.index === 0) {
+            return x.element;
+        }
+        return `${x.element}.${x.index}`;
+    })
+        .join(" ");
+};

package/dist/bezier.d.ts

@@ -0,0 +1,74 @@
+import type { Draw, Point, SVGStroke } from "./data.js";
+/**
+ * 一段 Bezier 曲线的主要朝向
+ * 例如，横笔画的朝向是水平的，竖笔画的朝向是垂直的
+ * 而撇和捺笔画的朝向可能是水平或垂直的，取决于它是平撇还是撇、平捺还是捺
+ */
+type Orientation = "horizontal" | "vertical";
+/**
+ * 一次 Bezier 曲线
+ * 用于表示横、竖等笔画
+ */
+interface LinearCurve {
+    type: "linear";
+    orientation: Orientation;
+    controls: [Point, Point];
+}
+/**
+ * 三次 Bezier 曲线
+ * 用于表示撇、捺等笔画
+ */
+interface CubicCurve {
+    type: "cubic";
+    orientation: Orientation;
+    controls: [Point, Point, Point, Point];
+}
+/**
+ * 圆弧曲线
+ * 用于表示笔画「圈」
+ */
+interface ArcCurve {
+    type: "arc";
+    orientation: Orientation;
+    controls: [Point, Point];
+}
+/**
+ * Bezier 曲线，可能为一次、三次或圆弧
+ */
+type Curve = LinearCurve | CubicCurve | ArcCurve;
+/**
+ * 渲染后的笔画
+ * 这个类型和 SVGStroke 的区别是，这个类型包含了一系列 Bezier 曲线，而 SVGStroke 包含了一系列 SVG 命令
+ * Bezier 曲线里每一段的起点和终点都是显式写出的，所以比较适合于计算
+ */
+interface RenderedStroke {
+    feature: string;
+    curveList: Curve[];
+}
+export declare const sortTwoNumbers: (ar: [number, number]) => [number, number];
+declare const getBoundingBox: (a: Curve) => [Point, Point];
+declare const getIntervalOnOrientation: (a: Curve) => [Interval, Interval];
+declare const makeCurve: (start: Point, { command, parameterList }: Draw) => Curve;
+declare const render: ({ feature, start, curveList }: SVGStroke) => RenderedStroke;
+declare const area: (p: Point, q: Point) => number;
+type Interval = [number, number];
+interface BoundingBox {
+    x: Interval;
+    y: Interval;
+}
+type Position = -1 | -0.5 | 0 | 0.5 | 1;
+declare const getIntervalPosition: (i: Interval, j: Interval) => Position;
+declare const findCrossPoint: (a: Curve, at: Interval, b: Curve, bt: Interval) => Point | undefined;
+/**
+ * Determine if the point is on a given segment
+ * @param from - starting point
+ * @param to - end point
+ * @param point - another point
+ * @returns
+ */
+declare const isCollinear: (from: Point, to: Point, point: Point) => boolean;
+declare const curveLength: (curve: Curve) => number;
+declare const isBoundedBy: (stroke: RenderedStroke, xrange: Interval, yrange: Interval) => boolean;
+export { getBoundingBox, getIntervalOnOrientation, getIntervalPosition, render, makeCurve, area, curveLength, findCrossPoint, isCollinear, isBoundedBy, };
+export type { LinearCurve, CubicCurve, Curve, RenderedStroke };
+export type { Interval, Position, BoundingBox };