@finbheara/domain 0.39.0 → 0.40.0

package/README.md

@@ -45,7 +45,7 @@ ESM, Node ≥ 22 or Bun ≥ 1.4.2. MIT. Not affiliated with or endorsed by any d
 | `@finbheara/domain/ceili` | `ceili()`, `ceiliRelation`, `CEILI_NODES`: the céilí handbook dances |
 | `@finbheara/domain/dance` | `dance()`: a print read as a tune and a céilí dance, narrowed by its round |
 | `@finbheara/domain/age` | `Age.from`, `Age.fromYOB`, `Age.fromTitle`, `ageTitleToken`, `ageRelation`, `canOverlap`, `averageAge`, `isAveraged`, `intersectBirthYears`, `validYOB`, the age constants |
-| `@finbheara/domain/noun-index` | `createIndex`, `indexSchema`, `personEncoder`, and the `SqlHandle`/`NounEncoder` types: a database-backed name map (below) |
+| `@finbheara/domain/noun-index` | `createIndex`, `indexSchema`, `personEncoder`, `roleEncoder`, `roleSchoolGlob`, and the `SqlHandle`/`NounEncoder` types: a database-backed name map (below) |
 | `@finbheara/domain/dance-types` | `danceTypes()`, `DANCE_TYPES`, `rhythmOfTime`, and the shared `DanceMatch`/`DanceRelation`/`SetRhythm`/`TimeSignature` types |
 | `@finbheara/domain/promotion` | `samePromotedRow`, `samePromotedSchool`, `samePromotedHeir`, `samePromotedName`, `questionMarksRead`, `foldCharSynonyms`: is a row the same row after a promotion (below) |
 | `@finbheara/domain/person` | `seatName`, `dancerName`, `teacherName`, `roleName`, `roleSentinelOf`, `rolePrintsNoName`, `dancerPrintsNoName`, the role lists and `SHARED_ROW_SENTINELS`: a person's print read in its role (below) |
@@ -512,6 +512,28 @@ schools.nouns(11).map((s) => s.sn0);                   // ["Ardvarna Academy", "
 schools.get(read("Ardvarna Academy of Irish Dance (Calgary, AB)"), "sn3");  // [10]
 ```
 
+An adjudicator and a teacher are one type, a `RolePerson`: a name read in its role, the
+person's number in the register that lists them (`null` where none does), the role, and the
+ids of the schools the person is filed at. `roleEncoder` stores one as `personEncoder`'s
+columns plus `id`, `role` and `schools`. Its levels are `nn0`-`nn4` and `id`, and `id` is
+indexed. The name is re-read with `roleName`, so a print on a role's not-a-name list comes
+back refused. `schools` is one column, and `roleSchoolGlob(school)` matches a row filed at
+that school, the whole id and never a part of another:
+
+```ts
+import { roleEncoder, roleSchoolGlob } from "@finbheara/domain/noun-index";
+import { seatName, teacherName } from "@finbheara/domain/person";
+
+const staff = createIndex(db, roleEncoder(), { table: "staff" });  // after its indexSchema
+staff.add({ name: seatName("Aoife Ni Mhaolvarna"), id: "1001", role: "adjudicator", schools: ["s1", "s10"] }, 1);
+staff.add({ name: teacherName("Kestrel Evbatyrov"), id: null, role: "teacher", schools: ["s10"] }, 2);
+
+staff.find("id", "1001");                                          // [1]
+staff.get({ name: teacherName("AOIFE NÍ MHAOLVARNA"), id: null, role: "teacher", schools: [] }, "nn3");  // [1]
+staff.glob("schools", roleSchoolGlob("s10")).map((r) => r.value);  // [1, 2]
+staff.nouns(1)[0]?.schools;                                         // ["s1", "s10"]
+```
+
 `rows({ column: keys, ... })` answers every row where any column holds one of its keys, and
 `glob(column, pattern)` a SQLite `GLOB` on one column. An encoder is a plain object: add a
 column of your own by spreading one, `{ ...enc, columns: [...enc.columns, "k"], encode: (x) =>

package/dist/chunks/place-4dkz48q6.js

@@ -0,0 +1,122 @@
+import {
+  SHARED_ROW_SENTINELS2,
+  sentinelIn2
+} from "./place-tcgfvemw.js";
+
+import {
+  NAME_REFUSED,
+  isNoNamePrint,
+  personName
+} from "@finbheara/names/normalize";
+var ADJUDICATOR_SENTINELS2 = [
+  {
+    print: "withdrawn adjudicator",
+    authority: "`Withdrawn Adjudicator`: 180 seat cells, one panel sheet's empty seat"
+  },
+  {
+    print: "no school judge",
+    authority: "`No School Judge`: an entry form's option for an adjudicator's entry"
+  }
+];
+var DANCER_SENTINELS2 = [
+  {
+    print: "name withheld",
+    authority: "`Name Withheld`: 136 name cells, the entry platform printed that the name was withheld"
+  },
+  {
+    print: "test dancer",
+    authority: "`Test Dancer`: 7 name cells, an entry platform's test entry"
+  },
+  {
+    print: "none none",
+    authority: "`none none`: 4 name cells, the sentinel `none` typed into both name fields"
+  },
+  {
+    print: "not known",
+    authority: "`Not known`: 1 name cell"
+  },
+  {
+    print: "don t know",
+    authority: "`Don't Know`: 1 name cell"
+  }
+];
+var TEACHER_SENTINELS2 = [];
+var ROLE_SENTINELS2 = {
+  adjudicator: [...SHARED_ROW_SENTINELS2, ...ADJUDICATOR_SENTINELS2],
+  dancer: [...SHARED_ROW_SENTINELS2, ...DANCER_SENTINELS2],
+  teacher: [...SHARED_ROW_SENTINELS2, ...TEACHER_SENTINELS2]
+};
+var MATCHERS = {
+  adjudicator: sentinelIn2(ROLE_SENTINELS2.adjudicator),
+  dancer: sentinelIn2(ROLE_SENTINELS2.dancer),
+  teacher: sentinelIn2(ROLE_SENTINELS2.teacher)
+};
+function roleSentinelOf2(role, print) {
+  return MATCHERS[role](print);
+}
+var NO_PART = Object.freeze({ particles: [], base: "", parts: [], tradition: null });
+
+class RoleRefusedName {
+  [Symbol.toStringTag] = "PersonName";
+  nn0;
+  nn1;
+  nn2 = NAME_REFUSED;
+  nn3 = NAME_REFUSED;
+  nn4 = NAME_REFUSED;
+  surname = NO_PART;
+  given = [];
+  suffixes = [];
+  refusal;
+  verdict;
+  role;
+  sentinel;
+  constructor(read, role, sentinel) {
+    this.role = role;
+    this.sentinel = sentinel;
+    this.nn0 = read.nn0;
+    this.nn1 = read.nn1;
+    this.refusal = { rule: "placeholder", printed: read.nn0, value: NAME_REFUSED };
+    this.verdict = { kind: "refused", refusal: this.refusal, rules: read.verdict.rules };
+  }
+  toString() {
+    return this.nn2;
+  }
+  get length() {
+    return this.nn2.length;
+  }
+  surnameKey() {
+    return "";
+  }
+  givenFields() {
+    return [];
+  }
+  givenName() {
+    return "";
+  }
+  isTeam() {
+    return false;
+  }
+  isPerson() {
+    return false;
+  }
+  isEmpty() {
+    return false;
+  }
+  printsNoName() {
+    return true;
+  }
+}
+function roleName2(role, print, order, factory) {
+  const read = factory === undefined ? personName(print, order) : factory.parse(print, order);
+  const sentinel = MATCHERS[role](print);
+  return sentinel === undefined ? read : new RoleRefusedName(read, role, sentinel);
+}
+function rolePrintsNoName2(role, print) {
+  return MATCHERS[role](print) !== undefined || isNoNamePrint(print);
+}
+var dancerPrintsNoName2 = (print) => rolePrintsNoName2("dancer", print);
+var seatName2 = (print) => roleName2("adjudicator", print, "given-first");
+var dancerName2 = (print, order, factory) => roleName2("dancer", print, order, factory);
+var teacherName2 = (print, order) => roleName2("teacher", print, order);
+
+export { ADJUDICATOR_SENTINELS2, DANCER_SENTINELS2, TEACHER_SENTINELS2, ROLE_SENTINELS2, roleSentinelOf2, roleName2, rolePrintsNoName2, dancerPrintsNoName2, seatName2, dancerName2, teacherName2 };

package/dist/noun-index.js

@@ -1,3 +1,8 @@
+import"./chunks/place-tcgfvemw.js";
+import {
+  roleName2
+} from "./chunks/place-4dkz48q6.js";
+
 import {
   NAME_COLUMNS,
   NAME_LEVEL_COLUMNS,
@@ -226,8 +231,61 @@ function personEncoder(options = {}) {
     }
   };
 }
+var STAFF_ROLES = ["adjudicator", "teacher"];
+function roleEncoder(options = {}) {
+  const read = options.read ?? ((role, p, o) => roleName2(role, p, o));
+  const named = (role) => personEncoder({
+    read: (p, o) => read(role, p, o),
+    print: options.print,
+    reading: options.reading
+  });
+  const names = {
+    adjudicator: named("adjudicator"),
+    teacher: named("teacher")
+  };
+  const roleOf = (r) => {
+    if (STAFF_ROLES.includes(r))
+      return r;
+    throw new Error(`roleEncoder: ${JSON.stringify(r)} is not a role`);
+  };
+  const base = names.teacher;
+  return {
+    columns: [...base.columns, "id", "role", "schools"],
+    levels: [...base.levels, "id"],
+    indexed: [...base.indexed, "id"],
+    encode(x) {
+      for (const s of x.schools)
+        if (typeof s !== "string" || s === "")
+          throw new Error(`roleEncoder: ${JSON.stringify(s)} is not a school id`);
+      return {
+        ...names[roleOf(x.role)].encode(x.name),
+        id: x.id,
+        role: x.role,
+        schools: x.schools.length === 0 ? null : JSON.stringify(x.schools)
+      };
+    },
+    key: (x, level) => level === "id" ? x.id : nameColumns(x.name)[level],
+    decode(row) {
+      const role = roleOf(row.role);
+      const schools = row.schools ?? null;
+      return {
+        name: names[role].decode(row),
+        id: row.id ?? null,
+        role,
+        schools: schools === null ? [] : JSON.parse(schools)
+      };
+    }
+  };
+}
+var globLiteral = (s) => s.replace(/[*?[]/gu, (c) => `[${c}]`);
+function roleSchoolGlob(school) {
+  return `*[[,]${globLiteral(JSON.stringify(school))}[],]*`;
+}
 export {
+  STAFF_ROLES,
   createIndex,
   indexSchema,
-  personEncoder
+  personEncoder,
+  roleEncoder,
+  roleSchoolGlob
 };

package/dist/person.js

@@ -1,135 +1,32 @@
+import {
+  ADJUDICATOR_SENTINELS2,
+  DANCER_SENTINELS2,
+  TEACHER_SENTINELS2,
+  ROLE_SENTINELS2,
+  roleSentinelOf2,
+  roleName2,
+  rolePrintsNoName2,
+  dancerPrintsNoName2,
+  seatName2,
+  dancerName2,
+  teacherName2
+} from "./chunks/place-4dkz48q6.js";
 import {
   SHARED_ROW_SENTINELS2,
   sentinelIn2
 } from "./chunks/place-tcgfvemw.js";
-
-import {
-  NAME_REFUSED,
-  isNoNamePrint,
-  personName
-} from "@finbheara/names/normalize";
-var ADJUDICATOR_SENTINELS = [
-  {
-    print: "withdrawn adjudicator",
-    authority: "`Withdrawn Adjudicator`: 180 seat cells, one panel sheet's empty seat"
-  },
-  {
-    print: "no school judge",
-    authority: "`No School Judge`: an entry form's option for an adjudicator's entry"
-  }
-];
-var DANCER_SENTINELS = [
-  {
-    print: "name withheld",
-    authority: "`Name Withheld`: 136 name cells, the entry platform printed that the name was withheld"
-  },
-  {
-    print: "test dancer",
-    authority: "`Test Dancer`: 7 name cells, an entry platform's test entry"
-  },
-  {
-    print: "none none",
-    authority: "`none none`: 4 name cells, the sentinel `none` typed into both name fields"
-  },
-  {
-    print: "not known",
-    authority: "`Not known`: 1 name cell"
-  },
-  {
-    print: "don t know",
-    authority: "`Don't Know`: 1 name cell"
-  }
-];
-var TEACHER_SENTINELS = [];
-var ROLE_SENTINELS = {
-  adjudicator: [...SHARED_ROW_SENTINELS2, ...ADJUDICATOR_SENTINELS],
-  dancer: [...SHARED_ROW_SENTINELS2, ...DANCER_SENTINELS],
-  teacher: [...SHARED_ROW_SENTINELS2, ...TEACHER_SENTINELS]
-};
-var MATCHERS = {
-  adjudicator: sentinelIn2(ROLE_SENTINELS.adjudicator),
-  dancer: sentinelIn2(ROLE_SENTINELS.dancer),
-  teacher: sentinelIn2(ROLE_SENTINELS.teacher)
-};
-function roleSentinelOf(role, print) {
-  return MATCHERS[role](print);
-}
-var NO_PART = Object.freeze({ particles: [], base: "", parts: [], tradition: null });
-
-class RoleRefusedName {
-  [Symbol.toStringTag] = "PersonName";
-  nn0;
-  nn1;
-  nn2 = NAME_REFUSED;
-  nn3 = NAME_REFUSED;
-  nn4 = NAME_REFUSED;
-  surname = NO_PART;
-  given = [];
-  suffixes = [];
-  refusal;
-  verdict;
-  role;
-  sentinel;
-  constructor(read, role, sentinel) {
-    this.role = role;
-    this.sentinel = sentinel;
-    this.nn0 = read.nn0;
-    this.nn1 = read.nn1;
-    this.refusal = { rule: "placeholder", printed: read.nn0, value: NAME_REFUSED };
-    this.verdict = { kind: "refused", refusal: this.refusal, rules: read.verdict.rules };
-  }
-  toString() {
-    return this.nn2;
-  }
-  get length() {
-    return this.nn2.length;
-  }
-  surnameKey() {
-    return "";
-  }
-  givenFields() {
-    return [];
-  }
-  givenName() {
-    return "";
-  }
-  isTeam() {
-    return false;
-  }
-  isPerson() {
-    return false;
-  }
-  isEmpty() {
-    return false;
-  }
-  printsNoName() {
-    return true;
-  }
-}
-function roleName(role, print, order, factory) {
-  const read = factory === undefined ? personName(print, order) : factory.parse(print, order);
-  const sentinel = MATCHERS[role](print);
-  return sentinel === undefined ? read : new RoleRefusedName(read, role, sentinel);
-}
-function rolePrintsNoName(role, print) {
-  return MATCHERS[role](print) !== undefined || isNoNamePrint(print);
-}
-var dancerPrintsNoName = (print) => rolePrintsNoName("dancer", print);
-var seatName = (print) => roleName("adjudicator", print, "given-first");
-var dancerName = (print, order, factory) => roleName("dancer", print, order, factory);
-var teacherName = (print, order) => roleName("teacher", print, order);
 export {
-  ADJUDICATOR_SENTINELS,
-  DANCER_SENTINELS,
-  ROLE_SENTINELS,
+  ADJUDICATOR_SENTINELS2 as ADJUDICATOR_SENTINELS,
+  DANCER_SENTINELS2 as DANCER_SENTINELS,
+  ROLE_SENTINELS2 as ROLE_SENTINELS,
   SHARED_ROW_SENTINELS2 as SHARED_ROW_SENTINELS,
-  TEACHER_SENTINELS,
-  dancerName,
-  dancerPrintsNoName,
-  roleName,
-  rolePrintsNoName,
-  roleSentinelOf,
-  seatName,
+  TEACHER_SENTINELS2 as TEACHER_SENTINELS,
+  dancerName2 as dancerName,
+  dancerPrintsNoName2 as dancerPrintsNoName,
+  roleName2 as roleName,
+  rolePrintsNoName2 as rolePrintsNoName,
+  roleSentinelOf2 as roleSentinelOf,
+  seatName2 as seatName,
   sentinelIn2 as sentinelIn,
-  teacherName
+  teacherName2 as teacherName
 };

package/dist/types/noun-index.d.ts

@@ -1,4 +1,5 @@
 import { type PersonName, type ResolvedNameOrder, type TransitiveLevel } from "@finbheara/names/normalize";
+import { type PersonRole } from "./person.ts";
 export type SqlValue = string | number | bigint | null;
 export interface SqlStatement {
     run(...params: SqlValue[]): unknown;
@@ -65,3 +66,20 @@ export interface PersonEncoderOptions {
     readonly reading?: string;
 }
 export declare function personEncoder(options?: PersonEncoderOptions): NounEncoder<PersonName, TransitiveLevel>;
+export type StaffRole = Extract<PersonRole, "adjudicator" | "teacher">;
+export declare const STAFF_ROLES: readonly StaffRole[];
+export interface RolePerson {
+    readonly name: PersonName;
+    readonly id: string | null;
+    readonly role: StaffRole;
+    readonly schools: readonly string[];
+}
+export type RoleLevel = TransitiveLevel | "id";
+export type RoleReader = (role: StaffRole, print: string, order: ResolvedNameOrder) => PersonName;
+export interface RoleEncoderOptions {
+    readonly read?: RoleReader;
+    readonly print?: string;
+    readonly reading?: string;
+}
+export declare function roleEncoder(options?: RoleEncoderOptions): NounEncoder<RolePerson, RoleLevel>;
+export declare function roleSchoolGlob(school: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@finbheara/domain",
-	"version": "0.39.0",
+	"version": "0.40.0",
 	"description": "Places, CLRG regions, school names, ages, dances, competition titles and schedules, and a person's print in its role, as they are printed: read, compared and told apart",
 	"keywords": [
 		"places",