Improve UX

examples/yustar.yaml

@@ -26,7 +26,6 @@ analysis:
     no_cross: false
   selector:
     - 根少优先
-    - 全符笔顺
     - 连续笔顺
     - 结构完整
     - 能连不交

package.json

@@ -34,6 +34,7 @@
     "deep-object-diff": "^1.1.9",
     "immer": "^10.1.1",
     "jotai": "^2.8.0",
+    "jotai-location": "^0.5.5",
     "jotai-minidb": "^0.0.8",
     "jotai-optics": "^0.3.2",
     "js-md5": "^0.8.3",

scripts/analyze.ts

@@ -100,7 +100,6 @@ const analyze = (
   const estdup1 = [...map1.values()]
     .filter((x) => x.length > 1)
     .reduce((a, b) => a + estimate(b.length, alphabet), 0);
-  // console.log([...map2].sort((a, b) => b[1].length - a[1].length).slice(0, 10))
   const estdup2 = [...map2.values()]
     .filter((x) => x.length > 1)
     .reduce((a, b) => a + estimate(b.length, alphabet * alphabet), 0);

scripts/recursive.ts

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync } from "fs";
-import { Character, Compound, PrimitiveCharacter } from "~/lib";
+import type { Compound, PrimitiveCharacter } from "~/lib";
+import { Character } from "~/lib";
 
 const repertoire = JSON.parse(
   readFileSync("public/cache/repertoire.json", "utf-8"),

spec/affine.spec.ts

@@ -1,4 +1,5 @@
-import { affineMerge, Compound, SVGGlyph } from "~/lib";
+import type { Compound, SVGGlyph } from "~/lib";
+import { affineMerge } from "~/lib";
 import { describe, expect, it } from "vitest";
 
 describe("affine transformations", () => {

spec/analysis.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
+import type { SVGGlyph } from "~/lib";
 import {
-  SVGGlyph,
   analysis,
   assemble,
   classifier,
@@ -9,15 +9,15 @@ import {
   recursiveRenderComponent,
   recursiveRenderCompound,
 } from "~/lib";
-import { primitiveRepertoire, repertoire } from "./mock";
+import { focusAnalysis, primitiveRepertoire, repertoire } from "./mock";
 import { readFileSync } from "fs";
 
 describe("e2e test", () => {
   it("checks database integrity", () => {
     const config = examples["mswb"];
     const analysisResult = analysis(
       repertoire,
-      config,
+      focusAnalysis(config, repertoire),
       Object.keys(repertoire).filter(isValidCJKChar),
     );
     const { componentError, compoundError } = analysisResult;
@@ -27,7 +27,11 @@ describe("e2e test", () => {
 
     const assemblyResult = assemble(
       repertoire,
-      config,
+      {
+        algebra: config.algebra,
+        encoder: config.encoder,
+        keyboard: config.form,
+      },
       characters,
       [],
       analysisResult,

spec/component.spec.ts

@@ -11,7 +11,12 @@ import {
   renderRootList,
 } from "~/lib";
 import type { DerivedComponent, PrimitiveRepertoire } from "~/lib";
-import { primitiveRepertoire, repertoire, computedComponents } from "./mock";
+import {
+  primitiveRepertoire,
+  repertoire,
+  computedComponents,
+  focusAnalysis,
+} from "./mock";
 
 describe("pruning", () => {
   const strokes = 4;
@@ -44,13 +49,21 @@ describe("get component scheme", () => {
     name: "",
     data: "国标五分类",
     keyboard: "米十五笔",
-    encoder: "形音码",
+    encoder: "形音码（米十五笔）",
   });
-
-  const rootList = renderRootList(repertoire, config);
+  const analysisConfig = focusAnalysis(config, repertoire);
+  const rootList = renderRootList(repertoire, [
+    ...analysisConfig.primaryRoots,
+    ...analysisConfig.secondaryRoots,
+  ]);
   it("can get component scheme", () => {
     const 天 = computedComponents.天!;
-    const scheme = getComponentScheme(天, rootList, config, classifier);
+    const scheme = getComponentScheme(
+      天,
+      [...rootList.values()],
+      analysisConfig,
+      classifier,
+    );
     expect(scheme).toHaveProperty("sequence");
   });
 });

spec/degenerator.spec.ts

@@ -4,12 +4,11 @@ import {
   binaryToIndices,
   defaultDegenerator,
   generateSliceBinaries,
-  defaultConfig,
 } from "~/lib";
 import { describe, it, expect } from "vitest";
 import { create, all } from "mathjs";
 import { computedGlyphs2 as renderedGlyphs, computedComponents } from "./mock";
-import { RenderedGlyph } from "~/lib";
+import type { RenderedGlyph } from "~/lib";
 
 const { randomInt } = create(all!, {
   randomSeed: "a",
@@ -46,39 +45,43 @@ describe("bi-directional conversion", () => {
 describe("generate slice binaries", () => {
   it("should find multiple occurence of a root", () => {
     const { 丰, 十 } = computedComponents;
-    expect(generateSliceBinaries(defaultConfig, 丰!, 十!)).toEqual([9, 5, 3]);
+    expect(generateSliceBinaries(defaultDegenerator, 丰!, 十!)).toEqual([
+      9, 5, 3,
+    ]);
   });
 
   it("should be able to distinguish 土 and 士", () => {
     const { 土, 士, 王, 壬 } = computedComponents;
-    expect(generateSliceBinaries(defaultConfig, 王!, 土!)).toEqual([7]);
-    expect(generateSliceBinaries(defaultConfig, 王!, 士!)).toEqual([]);
-    expect(generateSliceBinaries(defaultConfig, 壬!, 土!)).toEqual([]);
-    expect(generateSliceBinaries(defaultConfig, 壬!, 士!)).toEqual([7]);
+    expect(generateSliceBinaries(defaultDegenerator, 王!, 土!)).toEqual([7]);
+    expect(generateSliceBinaries(defaultDegenerator, 王!, 士!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 壬!, 土!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 壬!, 士!)).toEqual([7]);
   });
 
   it("should be able to distinguish 未 and 末", () => {
     const { 未, 末, 朱, 耒 } = computedComponents;
-    expect(generateSliceBinaries(defaultConfig, 朱!, 未!)).toEqual([31]);
-    expect(generateSliceBinaries(defaultConfig, 耒!, 未!)).toEqual([47, 31]);
-    expect(generateSliceBinaries(defaultConfig, 朱!, 末!)).toEqual([]);
-    expect(generateSliceBinaries(defaultConfig, 耒!, 末!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 朱!, 未!)).toEqual([31]);
+    expect(generateSliceBinaries(defaultDegenerator, 耒!, 未!)).toEqual([
+      47, 31,
+    ]);
+    expect(generateSliceBinaries(defaultDegenerator, 朱!, 末!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 耒!, 末!)).toEqual([]);
   });
 
   it("should be able to distinguish 口 and 囗", () => {
     const { 口, 囗, 中, 日 } = computedComponents;
-    expect(generateSliceBinaries(defaultConfig, 中!, 口!)).toEqual([14]);
-    expect(generateSliceBinaries(defaultConfig, 中!, 囗!)).toEqual([]);
-    expect(generateSliceBinaries(defaultConfig, 日!, 口!)).toEqual([]);
-    expect(generateSliceBinaries(defaultConfig, 日!, 囗!)).toEqual([13]);
+    expect(generateSliceBinaries(defaultDegenerator, 中!, 口!)).toEqual([14]);
+    expect(generateSliceBinaries(defaultDegenerator, 中!, 囗!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 日!, 口!)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 日!, 囗!)).toEqual([13]);
   });
 
   it("should be able to distinguish 木无十 and 全字头", () => {
     const 木无十 = computedComponents["\ue087"]!;
     const 全字头 = computedComponents["\ue43d"]!;
     const { 朱 } = computedComponents;
-    expect(generateSliceBinaries(defaultConfig, 朱!, 木无十)).toEqual([3]);
-    expect(generateSliceBinaries(defaultConfig, 朱!, 全字头)).toEqual([]);
+    expect(generateSliceBinaries(defaultDegenerator, 朱!, 木无十)).toEqual([3]);
+    expect(generateSliceBinaries(defaultDegenerator, 朱!, 全字头)).toEqual([]);
   });
 });
 

spec/mock.ts

@@ -1,5 +1,11 @@
 import rawrepertoire from "../public/cache/repertoire.json";
-import type { BasicComponent, PrimitiveCharacter } from "~/lib";
+import type {
+  AnalysisConfig,
+  BasicComponent,
+  Config,
+  PrimitiveCharacter,
+  Repertoire,
+} from "~/lib";
 import { listToObject, determine, computeComponent } from "~/lib";
 
 export const primitiveRepertoire = Object.fromEntries(
@@ -22,3 +28,16 @@ export const computedGlyphs2 = Object.fromEntries(
     return [k, v.glyph];
   }),
 );
+
+export const focusAnalysis = (config: Config, repertoire: Repertoire) => {
+  const result: AnalysisConfig = {
+    analysis: config.analysis ?? {},
+    primaryRoots: new Set(
+      Object.keys(config.form.mapping).filter((x) => repertoire[x]),
+    ),
+    secondaryRoots: new Set(
+      Object.keys(config.form.grouping ?? []).filter((x) => repertoire[x]),
+    ),
+  };
+  return result;
+};

spec/selector.spec.ts

@@ -1,43 +1,50 @@
 import { describe, expect, it } from "vitest";
-import { length, bias, order, crossing, attaching, Scheme } from "~/lib";
+import type { Environment, Scheme } from "~/lib";
+import { length, bias, order, crossing, attaching, analysis } from "~/lib";
 import { select } from "~/lib";
-import { computedComponents, repertoire } from "./mock";
+import { computedComponents, focusAnalysis, repertoire } from "./mock";
 import { defaultConfig } from "~/lib";
 import { Config } from "~/lib";
 
+const analysisConfig = focusAnalysis(defaultConfig, repertoire);
 const { 天 } = computedComponents as any;
+const env: Environment = {
+  component: 天,
+  rootMap: new Map(),
+  ...analysisConfig,
+};
 
 const rootMap = new Map<number, string>();
 
 describe("length", () => {
   it("should measure the length of scheme", () => {
-    expect(length.key([8, 7], 天, defaultConfig, rootMap)).toBe(2);
+    expect(length.key([8, 7], env)).toBe(2);
   });
 });
 
 describe("bias", () => {
   it("should measure the bias of scheme", () => {
-    expect(bias.key([8, 7], 天, defaultConfig, rootMap)).toEqual([-1, -3]);
+    expect(bias.key([8, 7], env)).toEqual([-1, -3]);
   });
 });
 
 describe("order", () => {
   it("should measure the order of scheme", () => {
-    expect(order.key([8, 7], 天, defaultConfig, rootMap)).toEqual(0);
+    expect(order.key([8, 7], env)).toEqual(0);
   });
 });
 
 describe("crossing", () => {
   it("should measure the crossing of scheme", () => {
-    expect(crossing.key([8, 7], 天, defaultConfig, rootMap)).toBe(0);
-    expect(crossing.key([12, 3], 天, defaultConfig, rootMap)).toBe(1);
+    expect(crossing.key([8, 7], env)).toBe(0);
+    expect(crossing.key([12, 3], env)).toBe(1);
   });
 });
 
 describe("attaching", () => {
   it("should measure the attaching of scheme", () => {
-    expect(attaching.key([8, 7], 天, defaultConfig, rootMap)).toBe(1);
-    expect(attaching.key([12, 3], 天, defaultConfig, rootMap)).toBe(0);
+    expect(attaching.key([8, 7], env)).toBe(1);
+    expect(attaching.key([12, 3], env)).toBe(0);
   });
 });
 
@@ -46,7 +53,7 @@ describe("select", () => {
     expect(
       (
         select(
-          defaultConfig,
+          analysisConfig,
           天,
           [
             [12, 3],

spec/topology.spec.ts

@@ -1,7 +1,7 @@
 import { expect, describe, it } from "vitest";
-import type { StrokeRelation } from "~/lib";
+import type { StrokeRelation, CubicCurve, LinearCurve } from "~/lib";
 import { findTopology, curveRelation, renderSVGGlyph } from "~/lib";
-import { CubicCurve, LinearCurve, area, render } from "~/lib";
+import { area, render } from "~/lib";
 import type { Draw, Point } from "~/lib";
 import { computedGlyphs2 as computedGlyphs } from "./mock";
 import { getIntervalPosition, makeCurve } from "~/lib";

src/atoms/analysis.ts

@@ -1,7 +1,13 @@
-import type { Analysis, Degenerator, Selector, SieveName } from "~/lib";
+import type {
+  Analysis,
+  Degenerator,
+  Selector,
+  SieveName,
+  Feature,
+} from "~/lib";
 import { focusAtom } from "jotai-optics";
 import { analysisAtom } from "./config";
-import { Feature, mergeClassifier } from "~/lib";
+import { mergeClassifier } from "~/lib";
 import { atom } from "jotai";
 
 export const degeneratorAtom = focusAtom(analysisAtom, (o) =>

src/atoms/assets.ts

@@ -1,5 +1,5 @@
 import { atomWithStorage } from "jotai/utils";
-import { Dictionary, Distribution, Equivalence, Frequency } from ".";
+import type { Dictionary, Distribution, Equivalence, Frequency } from ".";
 import { MiniDb } from "jotai-minidb";
 
 const db = new MiniDb<Dictionary>();