hanzi-chai 0.3.0

package/dist/config.d.ts

@@ -0,0 +1,236 @@
+import type { Feature } from "./classifier.js";
+import { serializerMap } from "./compound.js";
+import type { Compound, PrimitiveRepertoire, Component, Reading, Identity } from "./data.js";
+import type { CodableObject } from "./element.js";
+import { type 变换器 } from "./transformer.js";
+export interface Info {
+    name?: string;
+    author?: string;
+    version?: string;
+    description?: string;
+}
+export declare const characterSetSpecifiers: readonly ["minimal", "gb2312", "general", "basic", "extended", "supplement", "maximal", "custom"];
+export type CharacterSetSpecifier = (typeof characterSetSpecifiers)[number];
+export interface Data {
+    character_set?: CharacterSetSpecifier;
+    repertoire?: PrimitiveRepertoire;
+    glyph_customization?: CustomGlyph;
+    reading_customization?: CustomReadings;
+    tags?: string[];
+    transformers?: 变换器[];
+}
+export type CustomGlyph = Record<string, Component | Compound | Identity>;
+export type CustomReadings = Record<string, Reading[]>;
+export interface Analysis {
+    classifier?: Record<Feature, number>;
+    degenerator?: Degenerator;
+    selector?: Selector;
+    customize?: Record<string, string[]>;
+    dynamic_customize?: Record<string, string[][]>;
+    strong?: string[];
+    weak?: string[];
+    serializer?: keyof typeof serializerMap;
+}
+export interface Degenerator {
+    feature?: Record<Feature, Feature>;
+    no_cross?: boolean;
+}
+export type SieveName = "根少优先" | "连续笔顺" | "全符笔顺" | "能连不交" | "能散不连" | "同向笔画" | "取大优先" | "取小优先" | "结构完整" | "多强字根" | "少弱字根" | "非形近根";
+export type Selector = SieveName[];
+export type Algebra = Record<string, Rule[]>;
+export type Rule = Transformation | Transliteration;
+interface Transformation {
+    type: "xform";
+    from: string;
+    to: string;
+}
+interface Transliteration {
+    type: "xlit";
+    from: string;
+    to: string;
+}
+export interface Keyboard {
+    alphabet?: string;
+    mapping_type?: number;
+    mapping: Mapping;
+    mapping_space?: MappingSpace;
+    mapping_variables?: Record<string, MappingVariableRule>;
+    mapping_generators?: MappingGeneratorRule[];
+    grouping?: Record<string, string>;
+}
+export interface MappingVariableRule {
+    keys: string[];
+}
+export interface MappingGeneratorRule {
+    regex: string;
+    value: ValueDescription;
+}
+export type Element = string;
+export type ElementWithIndex = {
+    element: string;
+    index: number;
+};
+export type Key = string | ElementWithIndex;
+export type Value = null | string | Key[] | {
+    element: string;
+};
+export type VariableKey = {
+    variable: string;
+};
+export type GeneralizedKey = Key | VariableKey | null;
+export declare function isVariableKey(key: GeneralizedKey): key is VariableKey;
+export type GeneralizedValue = null | string | GeneralizedKey[] | {
+    element: string;
+};
+export declare function isMerge(value: GeneralizedValue): value is {
+    element: string;
+};
+export type Mapping = Record<Element, Exclude<Value, null>>;
+export interface ValueDescription {
+    value: GeneralizedValue;
+    score: number;
+    condition?: {
+        element: string;
+        op: "是" | "不是";
+        value: Value;
+    }[];
+}
+export type MappingSpace = Record<Element, ValueDescription[]>;
+export interface EncoderConfig {
+    max_length: number;
+    select_keys?: string[];
+    auto_select_length?: number;
+    auto_select_pattern?: string;
+    sources: Record<string, Source>;
+    conditions: Record<string, Condition>;
+    rules?: WordRule[];
+    short_code?: ShortCodeRule[];
+    priority_short_codes?: [string, string, number][];
+}
+export interface Source {
+    object: CodableObject | null;
+    index?: number;
+    next: string | null;
+}
+export declare const binaryOps: readonly ["是", "不是", "匹配", "不匹配", "编码匹配", "编码不匹配"];
+export declare const unaryOps: readonly ["存在", "不存在"];
+export declare const ops: Op[];
+export type UnaryOp = (typeof unaryOps)[number];
+export type BinaryOp = (typeof binaryOps)[number];
+export type Op = UnaryOp | BinaryOp;
+export interface UnaryCondition {
+    object: CodableObject;
+    operator: UnaryOp;
+    positive: string | null;
+    negative: string | null;
+}
+export interface BinaryCondition {
+    object: CodableObject;
+    operator: BinaryOp;
+    value: string;
+    positive: string | null;
+    negative: string | null;
+}
+export type Condition = UnaryCondition | BinaryCondition;
+type LengthSpecifier = {
+    length_equal: number;
+} | {
+    length_in_range: [number, number];
+};
+export declare const wordLengthArray: {
+    label: number;
+    value: number;
+}[];
+export type WordRule = {
+    formula: string;
+} & LengthSpecifier;
+export type ShortCodeRule = {
+    schemes: ShortCodeScheme[];
+} & LengthSpecifier;
+export interface ShortCodeScheme {
+    prefix: number;
+    count?: number;
+    select_keys?: string[];
+}
+export interface LevelWeights {
+    length: number;
+    frequency: number;
+}
+export type FingeringWeights = (number | null)[];
+export interface TierWeights {
+    top?: number;
+    duplication?: number;
+    levels?: LevelWeights[];
+    fingering?: FingeringWeights;
+}
+export declare const fingeringLabels: string[];
+export interface PartialWeights {
+    tiers?: TierWeights[];
+    duplication?: number;
+    key_distribution?: number;
+    pair_equivalence?: number;
+    extended_pair_equivalence?: number;
+    fingering?: FingeringWeights;
+    levels?: LevelWeights[];
+}
+export interface Objective {
+    characters_full?: PartialWeights;
+    characters_short?: PartialWeights;
+    words_full?: PartialWeights;
+    words_short?: PartialWeights;
+    regularization_strength?: number;
+}
+export type PartialWeightTypes = Exclude<keyof Objective, "regularization">;
+export interface Optimization {
+    objective: Objective;
+    metaheuristic: Solver;
+}
+export declare const defaultOptimization: Optimization;
+export interface Solver {
+    algorithm: "SimulatedAnnealing";
+    parameters?: {
+        t_max: number;
+        t_min: number;
+        steps: number;
+    };
+    report_after?: number;
+    search_method?: {
+        random_move: number;
+        random_swap: number;
+        random_full_key_swap: number;
+    };
+    update_interval?: number;
+}
+export type BoxConfig = {
+    style?: string;
+} & ({
+    type: "key" | "uppercase";
+} | {
+    type: "element";
+    match?: string;
+} | {
+    type: "custom";
+    mapping?: string;
+});
+export interface DiagramConfig {
+    layout: {
+        keys: string[];
+    }[];
+    contents: BoxConfig[];
+    row_style?: string;
+    cell_style?: string;
+}
+export interface Config {
+    version?: string;
+    source: string | null;
+    info?: Info;
+    data?: Data;
+    analysis?: Analysis;
+    algebra?: Algebra;
+    form: Keyboard;
+    encoder: EncoderConfig;
+    optimization?: Optimization;
+    diagram?: DiagramConfig;
+}
+export type ExampleConfig = Required<Config>;
+export {};

package/dist/config.js

@@ -0,0 +1,48 @@
+// config.info end
+// config.data begin
+export const characterSetSpecifiers = [
+    "minimal",
+    "gb2312",
+    "general",
+    "basic",
+    "extended",
+    "supplement",
+    "maximal",
+    "custom",
+];
+export function isVariableKey(key) {
+    return typeof key === "object" && key !== null && "variable" in key;
+}
+export function isMerge(value) {
+    return typeof value === "object" && value !== null && "element" in value;
+}
+export const binaryOps = [
+    "是",
+    "不是",
+    "匹配",
+    "不匹配",
+    "编码匹配",
+    "编码不匹配",
+];
+export const unaryOps = ["存在", "不存在"];
+export const ops = unaryOps.concat(...binaryOps);
+export const wordLengthArray = [...Array(9).keys()].map((x) => ({
+    label: x + 1,
+    value: x + 1,
+}));
+export const fingeringLabels = [
+    "同手",
+    "大跨",
+    "小跨",
+    "干扰",
+    "错手",
+    "三连",
+    "备用",
+    "备用",
+];
+export const defaultOptimization = {
+    objective: {},
+    metaheuristic: {
+        algorithm: "SimulatedAnnealing",
+    },
+};