glossarist 0.4.39 → 0.4.40

package/src/models/register.ts

@@ -0,0 +1,315 @@
+import { GlossaristModel } from './base.js';
+import { Section } from './section.js';
+import type { SectionJson } from './section.js';
+import { resolveColor } from './dataset-color.js';
+import type { DatasetColor } from './dataset-color.js';
+import type { LocalizedString } from './generic-member.js';
+
+export const REGISTER_STATUSES: ReadonlyArray<string> = Object.freeze([
+  'current',
+  'superseded',
+  'withdrawn',
+  'draft',
+]);
+
+export interface RegisterJson {
+  schema_version?: string;
+  schemaVersion?: string;
+  id?: string | null;
+  name?: string | LocalizedString | null;
+  ref?: string | null;
+  refAliases?: ReadonlyArray<string>;
+  ref_aliases?: ReadonlyArray<string>;
+  year?: number | string | null;
+  urn?: string | null;
+  urnAliases?: ReadonlyArray<string>;
+  urn_aliases?: ReadonlyArray<string>;
+  status?: string | null;
+  supersedes?: string | null;
+  owner?: string | null;
+  sourceRepo?: string | null;
+  source_repo?: string | null;
+  tags?: ReadonlyArray<string>;
+  languages?: ReadonlyArray<string>;
+  languageOrder?: ReadonlyArray<string>;
+  language_order?: ReadonlyArray<string>;
+  ordering?: string | null;
+  logo?: Record<string, unknown> | null;
+  color?: DatasetColor | null;
+  description?: LocalizedString;
+  about?: LocalizedString;
+  provenance?: ReadonlyArray<Record<string, unknown>>;
+  contributors?: ReadonlyArray<Record<string, unknown>>;
+  sections?: ReadonlyArray<SectionJson | Section>;
+  [key: string]: unknown;
+}
+
+export class Register extends GlossaristModel {
+  readonly schemaVersion: string;
+  readonly id: string | null;
+  readonly name: string | LocalizedString | null;
+  readonly ref: string | null;
+  readonly refAliases: ReadonlyArray<string>;
+  readonly year: number | string | null;
+  readonly urn: string | null;
+  readonly urnAliases: ReadonlyArray<string>;
+  readonly status: string | null;
+  readonly supersedes: string | null;
+  readonly owner: string | null;
+  readonly sourceRepo: string | null;
+  readonly tags: ReadonlyArray<string>;
+  readonly languages: ReadonlyArray<string>;
+  readonly languageOrder: ReadonlyArray<string>;
+  readonly ordering: string | null;
+  readonly logo: Record<string, unknown> | null;
+  readonly color: DatasetColor | null;
+  readonly description: LocalizedString;
+  readonly about: LocalizedString;
+  readonly provenance: ReadonlyArray<Record<string, unknown>>;
+  readonly contributors: ReadonlyArray<Record<string, unknown>>;
+  readonly sections: ReadonlyArray<Section>;
+  private readonly _raw: Record<string, unknown>;
+
+  constructor(data: RegisterJson = {}) {
+    super();
+    this.schemaVersion = data.schema_version ?? data.schemaVersion ?? '3';
+    this.id = data.id ?? null;
+    this.name = (data.name as string | LocalizedString | null) ?? null;
+    this.ref = data.ref ?? null;
+    this.refAliases = data.refAliases ?? data.ref_aliases ?? [];
+    this.year = (data.year as number | string | null) ?? null;
+    this.urn = data.urn ?? null;
+    this.urnAliases = data.urnAliases ?? data.urn_aliases ?? [];
+    this.status = data.status ?? null;
+    this.supersedes = data.supersedes ?? null;
+    this.owner = data.owner ?? null;
+    this.sourceRepo = data.sourceRepo ?? data.source_repo ?? null;
+    this.tags = (data.tags as ReadonlyArray<string>) ?? [];
+    this.languages = (data.languages as ReadonlyArray<string>) ?? [];
+    this.languageOrder = data.languageOrder ?? data.language_order ?? [];
+    this.ordering = data.ordering ?? null;
+    this.logo = (data.logo as Record<string, unknown> | null) ?? null;
+    this.color = (data.color as DatasetColor | null) ?? null;
+    this.description = (data.description as LocalizedString) ?? {};
+    this.about = (data.about as LocalizedString) ?? {};
+    this.provenance = (data.provenance as ReadonlyArray<Record<string, unknown>>) ?? [];
+    this.contributors = (data.contributors as ReadonlyArray<Record<string, unknown>>) ?? [];
+    this.sections = (data.sections ?? []).map((s) =>
+      s instanceof Section ? s : new Section(s as SectionJson),
+    );
+    this._raw = this._extractRaw(data);
+  }
+
+  private _extractRaw(data: RegisterJson): Record<string, unknown> {
+    const known = new Set([
+      'schema_version', 'schemaVersion',
+      'id', 'name', 'ref', 'refAliases', 'ref_aliases',
+      'year', 'urn', 'urnAliases', 'urn_aliases',
+      'status', 'supersedes', 'owner',
+      'sourceRepo', 'source_repo', 'tags',
+      'languages', 'languageOrder', 'language_order',
+      'ordering', 'logo', 'color', 'description', 'about',
+      'provenance', 'contributors', 'sections',
+    ]);
+    const extra: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (!known.has(k)) extra[k] = v;
+    }
+    return extra;
+  }
+
+  sectionById(id: string): Section | null {
+    for (const section of this.sections) {
+      if (section.id === id) return section;
+      const found = section.descendantById(id);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  /**
+   * Walks the section tree upward from `sectionId`, returning the
+   * ancestor chain in immediate-parent-first order. The returned array
+   * does NOT include sectionId itself. Returns [] when sectionId is
+   * unknown or is a top-level section.
+   */
+  sectionAncestorIds(sectionId: string | null | undefined): string[] {
+    if (!sectionId) return [];
+    for (const root of this.sections) {
+      const chain = _ancestorChain(root, sectionId);
+      if (chain) return chain;
+    }
+    return [];
+  }
+
+  /**
+   * Returns the closure of `sectionId`: the section plus all of its
+   * ancestors. Concept-section membership tests should intersect the
+   * concept's section list with this closure.
+   */
+  sectionClosure(sectionId: string | null | undefined): string[] {
+    return sectionId ? [sectionId, ...this.sectionAncestorIds(sectionId)] : [];
+  }
+
+  /**
+   * Walks the section tree DOWNWARD from `sectionId`, returning all
+   * descendant section IDs in pre-order.
+   */
+  sectionDescendantIds(sectionId: string | null | undefined): string[] {
+    if (!sectionId) return [];
+    const section = this.sectionById(sectionId);
+    if (!section) return [];
+    const out: string[] = [];
+    for (const child of section.children) {
+      if (child.id) out.push(child.id);
+      out.push(...this.sectionDescendantIds(child.id));
+    }
+    return out;
+  }
+
+  sectionDescendantClosure(sectionId: string | null | undefined): string[] {
+    return sectionId ? [sectionId, ...this.sectionDescendantIds(sectionId)] : [];
+  }
+
+  /**
+   * Returns all section IDs the concept belongs to: the concept's own
+   * sections plus every ancestor of each.
+   */
+  conceptSectionIds(concept: { sections?: unknown; groups?: unknown }): string[] {
+    const own = conceptSectionIdList(concept);
+    if (own.length === 0) return [];
+    const closure = new Set<string>();
+    for (const id of own) {
+      for (const ancestor of this.sectionClosure(id)) closure.add(ancestor);
+    }
+    return [...closure];
+  }
+
+  sectionName(sectionId: string, lang: string): string | null {
+    const section = this.sectionById(sectionId);
+    return section ? section.name(lang) : null;
+  }
+
+  /**
+   * Localized display name. Returns the best-matching name string for
+   * the requested language, falling back to English, then to the first
+   * available language, then to null.
+   */
+  displayName(lang: string): string | null {
+    if (this.name == null) return null;
+    if (typeof this.name === 'string') return this.name;
+    if (typeof this.name === 'object') {
+      return (
+        this.name[lang] ??
+        this.name['eng'] ??
+        (Object.values(this.name)[0] as string | undefined) ??
+        null
+      );
+    }
+    return null;
+  }
+
+  resolvedColor(mode: 'light' | 'dark'): string | null {
+    return resolveColor(this.color, mode);
+  }
+
+  override toJSON(): RegisterJson {
+    const obj = { ...this._raw, schema_version: this.schemaVersion } as RegisterJson;
+    if (this.id != null) obj.id = this.id;
+    if (this.name != null) obj.name = this.name;
+    if (this.ref != null) obj.ref = this.ref;
+    if (this.refAliases.length > 0) obj.refAliases = [...this.refAliases];
+    if (this.year != null) obj.year = this.year;
+    if (this.urn != null) obj.urn = this.urn;
+    if (this.urnAliases.length > 0) obj.urnAliases = [...this.urnAliases];
+    if (this.status != null) obj.status = this.status;
+    if (this.supersedes != null) obj.supersedes = this.supersedes;
+    if (this.owner != null) obj.owner = this.owner;
+    if (this.sourceRepo != null) obj.sourceRepo = this.sourceRepo;
+    if (this.tags.length > 0) obj.tags = [...this.tags];
+    if (this.languages.length > 0) obj.languages = [...this.languages];
+    if (this.languageOrder.length > 0) obj.languageOrder = [...this.languageOrder];
+    if (this.ordering != null) obj.ordering = this.ordering;
+    if (this.logo != null) obj.logo = { ...this.logo };
+    if (this.color != null) {
+      obj.color =
+        typeof this.color === 'object' && this.color !== null
+          ? { ...this.color }
+          : this.color;
+    }
+    if (Object.keys(this.description).length > 0) obj.description = { ...this.description };
+    if (Object.keys(this.about).length > 0) obj.about = { ...this.about };
+    if (this.provenance.length > 0) obj.provenance = this.provenance.map((p) => ({ ...p }));
+    if (this.contributors.length > 0) obj.contributors = this.contributors.map((c) => ({ ...c }));
+    if (this.sections.length > 0) obj.sections = this.sections.map((s) => s.toJSON());
+    return obj;
+  }
+
+  static override fromJSON(data: RegisterJson): Register {
+    const instance = new Register(data);
+    const snakeToCamel = (k: string): string =>
+      k.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase());
+    return new Proxy(instance, {
+      get(target: Register, prop: string | symbol): unknown {
+        if (typeof prop === 'string') {
+          if (prop in target) return (target as unknown as Record<string, unknown>)[prop];
+          if (prop in target._raw) return target._raw[prop];
+          const camel = snakeToCamel(prop);
+          if (camel in target) return (target as unknown as Record<string, unknown>)[camel];
+        }
+        return undefined;
+      },
+    });
+  }
+}
+
+/**
+ * Recursive walk: returns the ancestor chain of `targetId` within the
+ * subtree rooted at `section`, or null if targetId is not in this
+ * subtree.
+ */
+function _ancestorChain(
+  section: Section,
+  targetId: string,
+  ancestors: string[] = [],
+): string[] | null {
+  if (section.id === targetId) return [...ancestors].reverse();
+  for (const child of section.children) {
+    const childId = child.id;
+    if (childId == null) continue;
+    const nextAncestors = section.id != null ? [...ancestors, section.id] : [...ancestors];
+    const found = _ancestorChain(child, targetId, nextAncestors);
+    if (found) return found;
+  }
+  return null;
+}
+
+/**
+ * Returns the list of section IDs a concept claims membership in.
+ * Concepts may carry section IDs via either `sections` (preferred) or
+ * `groups` (legacy). Each entry may be a string or an object with an
+ * `id` field; both forms are flattened to a string list.
+ */
+function conceptSectionIdList(concept: { sections?: unknown; groups?: unknown }): string[] {
+  if (!concept) return [];
+  const fromSections = concept.sections
+    ? _flattenSectionIds(concept.sections)
+    : [];
+  const fromGroups = concept.groups ? _flattenSectionIds(concept.groups) : [];
+  return [...fromSections, ...fromGroups];
+}
+
+function _flattenSectionIds(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const out: string[] = [];
+  for (const entry of value) {
+    if (typeof entry === 'string') {
+      out.push(entry);
+    } else if (entry && typeof entry === 'object') {
+      const e = entry as { id?: string; sectionId?: string; ref?: { id?: string } };
+      const id = e.id ?? e.sectionId ?? e.ref?.id;
+      if (id) out.push(String(id));
+    }
+  }
+  return out;
+}

package/src/models/relation-categories.ts

@@ -0,0 +1,167 @@
+// Categorization SSOT for the 52 glossarist relationship types.
+
+import { RELATIONSHIP_TYPES } from './related-concept.js';
+
+export interface CategoryDefinition {
+  label: string;
+  description: string;
+  types: ReadonlyArray<string>;
+}
+
+type CategoryKey =
+  | 'lifecycle'
+  | 'hierarchical'
+  | 'associative'
+  | 'comparative'
+  | 'spatiotemporal'
+  | 'lexical'
+  | 'mapping'
+  | 'definitional';
+
+/**
+ * Each type in RELATIONSHIP_TYPES belongs to exactly one category. The
+ * categories mirror the concept-model taxonomy. Adding a new type
+ * means adding a taxonomy entry — no code changes here.
+ */
+export const RELATION_CATEGORIES: Readonly<Record<CategoryKey, CategoryDefinition>> = Object.freeze({
+  lifecycle: Object.freeze({
+    label: 'Lifecycle',
+    description: 'Concept lifecycle transitions: supersession, deprecation, replacement.',
+    types: Object.freeze([
+      'deprecates', 'deprecated_by',
+      'supersedes', 'superseded_by',
+      'replaces', 'replaced_by',
+      'invalidates', 'invalidated_by',
+      'retires', 'retired_by',
+    ]),
+  }) as CategoryDefinition,
+
+  hierarchical: Object.freeze({
+    label: 'Hierarchical',
+    description: 'Broader/narrower relations, including SKOS and ISO 25964 generic/partitive/instantial.',
+    types: Object.freeze([
+      'broader', 'narrower',
+      'broader_generic', 'narrower_generic',
+      'broader_partitive', 'narrower_partitive',
+      'broader_instantial', 'narrower_instantial',
+    ]),
+  }) as CategoryDefinition,
+
+  associative: Object.freeze({
+    label: 'Associative',
+    description: 'Generic see-also references between concepts.',
+    types: Object.freeze([
+      'see', 'related_concept',
+      'related_concept_broader', 'related_concept_narrower',
+      'references',
+    ]),
+  }) as CategoryDefinition,
+
+  comparative: Object.freeze({
+    label: 'Comparative',
+    description: 'Compare / contrast relations between concepts.',
+    types: Object.freeze(['compare', 'contrast']),
+  }) as CategoryDefinition,
+
+  spatiotemporal: Object.freeze({
+    label: 'Spatiotemporal',
+    description: 'Sequential, spatial, and temporal relations.',
+    types: Object.freeze([
+      'sequentially_related_concept',
+      'spatially_related_concept',
+      'temporally_related_concept',
+    ]),
+  }) as CategoryDefinition,
+
+  lexical: Object.freeze({
+    label: 'Lexical',
+    description: 'Lexical relations between designations across languages.',
+    types: Object.freeze(['homograph', 'false_friend']),
+  }) as CategoryDefinition,
+
+  mapping: Object.freeze({
+    label: 'Mapping',
+    description: 'SKOS mapping properties for cross-vocabulary alignment.',
+    types: Object.freeze([
+      'equivalent', 'close_match',
+      'broad_match', 'narrow_match', 'related_match',
+    ]),
+  }) as CategoryDefinition,
+
+  definitional: Object.freeze({
+    label: 'Definitional',
+    description: 'ISO 19135 concept-to-concept relations: definition, part, instance, inheritance, versioning.',
+    types: Object.freeze([
+      'has_concept', 'is_concept_of',
+      'instance_of', 'has_instance',
+      'has_definition', 'definition_of',
+      'has_part', 'is_part_of',
+      'inherits', 'inherited_by',
+      'has_version', 'version_of',
+      'current_version', 'current_version_of',
+      'provides', 'provided_by',
+    ]),
+  }) as CategoryDefinition,
+});
+
+const _CATEGORY_BY_TYPE: ReadonlyMap<string, string> = (() => {
+  const map = new Map<string, string>();
+  for (const [cat, def] of Object.entries(RELATION_CATEGORIES)) {
+    for (const t of def.types) map.set(t, cat);
+  }
+  return map;
+})();
+
+const _CATEGORY_ALIASES: Readonly<Record<string, string>> = {
+  conceptInstance: 'definitional',
+  versioning: 'definitional',
+};
+
+/**
+ * Returns the category key for the given relationship type, or null
+ * when the type is not categorized.
+ */
+export function categoryOf(type: string): string | null {
+  return _CATEGORY_BY_TYPE.get(type) ?? null;
+}
+
+/**
+ * Returns the category definition for the given category key.
+ * Accepts both canonical names (definitional) and aliases from
+ * earlier glossarist-js versions.
+ */
+export function categoryDefinition(categoryKey: string): CategoryDefinition | null {
+  const canonical = _CATEGORY_ALIASES[categoryKey] ?? categoryKey;
+  return (RELATION_CATEGORIES as Readonly<Record<string, CategoryDefinition>>)[canonical] ?? null;
+}
+
+/**
+ * MECE sanity check. Returns the list of relationship types that are
+ * NOT categorized.
+ */
+export function uncategorizedTypes(): string[] {
+  return RELATIONSHIP_TYPES.filter((t) => !_CATEGORY_BY_TYPE.has(t));
+}
+
+/**
+ * MECE sanity check. Returns a list of { type, count } entries for any
+ * type that appears in MORE than one category.
+ */
+export function duplicatedTypes(): ReadonlyArray<{ type: string; count: number }> {
+  const counts = new Map<string, number>();
+  for (const def of Object.values(RELATION_CATEGORIES)) {
+    for (const t of def.types) {
+      counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+  }
+  const out: { type: string; count: number }[] = [];
+  for (const [type, count] of counts) {
+    if (count > 1) out.push({ type, count });
+  }
+  return out;
+}
+
+export {
+  RELATION_CATEGORIES as RELATION_CATEGORIES_READONLY,
+  type CategoryKey as RelationCategoryKey,
+};

package/src/models/{relation-colors.js → relation-colors.ts}

@@ -6,10 +6,27 @@
 
 import { categoryOf, categoryDefinition } from './relation-categories.js';
 
-// One { light, dark } pair per category. Keeping these in glossarist-js
-// lets the defaults ship with the library; consumers only need to
-// customize when they want to deviate.
-export const RELATION_COLOR_DEFAULTS = Object.freeze({
+export interface ColorPair {
+  light: string;
+  dark: string;
+}
+
+export interface RelationColorPalette {
+  byCategory: Readonly<Record<string, ColorPair>>;
+  byType: Readonly<Record<string, ColorPair>>;
+}
+
+export interface ResolveRelationColorOptions {
+  overrides?: Partial<RelationColorPalette>;
+  mode?: 'light' | 'dark';
+}
+
+/**
+ * One { light, dark } pair per category. Keeping these in glossarist-js
+ * lets the defaults ship with the library; consumers only need to
+ * customize when they want to deviate.
+ */
+export const RELATION_COLOR_DEFAULTS: RelationColorPalette = Object.freeze({
   byCategory: Object.freeze({
     lifecycle:      { light: '#B43A2E', dark: '#F87171' },
     hierarchical:   { light: '#1F6FEB', dark: '#6EA8FE' },
@@ -19,39 +36,32 @@ export const RELATION_COLOR_DEFAULTS = Object.freeze({
     lexical:        { light: '#D97706', dark: '#FBBF24' },
     mapping:        { light: '#2563EB', dark: '#93BBFD' },
     definitional:   { light: '#65A30D', dark: '#A3E635' },
-  }),
-
-  // Per-type overrides. Use the same { light, dark } shape. Keys are
-  // relationship-type local names. Empty by default — consumers may
-  // populate this through `overrides.byType` at call time.
-  byType: Object.freeze({}),
+  }) as Readonly<Record<string, ColorPair>>,
+  byType: Object.freeze({}) as Readonly<Record<string, ColorPair>>,
 });
 
 /**
- * Resolves the color for a relationship type.
- *
- * Resolution order:
+ * Resolves the color for a relationship type. Resolution order:
  *   1. overrides.byType[type]
  *   2. RELATION_COLOR_DEFAULTS.byType[type]
  *   3. overrides.byCategory[category]
  *   4. RELATION_COLOR_DEFAULTS.byCategory[category]
  *   5. null (uncategorized or unrecognized type)
- *
- * @param {string} type - relationship type local name
- * @param {{ overrides?: { byType?: object, byCategory?: object }, mode?: 'light'|'dark' }} [options]
- * @returns {string | null}
  */
-export function resolveRelationColor(type, options = {}) {
+export function resolveRelationColor(
+  type: string,
+  options: ResolveRelationColorOptions = {},
+): string | null {
   const mode = options.mode ?? 'light';
   const overrides = options.overrides ?? {};
-
   const typeOverride = overrides.byType?.[type] ?? RELATION_COLOR_DEFAULTS.byType[type];
   if (typeOverride) return pickMode(typeOverride, mode);
 
   const category = categoryOf(type);
   if (!category) return null;
 
-  const categoryOverride = overrides.byCategory?.[category] ?? RELATION_COLOR_DEFAULTS.byCategory[category];
+  const categoryOverride =
+    overrides.byCategory?.[category] ?? RELATION_COLOR_DEFAULTS.byCategory[category];
   if (!categoryOverride) return null;
 
   return pickMode(categoryOverride, mode);
@@ -61,16 +71,19 @@ export function resolveRelationColor(type, options = {}) {
  * Returns the { light, dark } pair for a category, merging overrides
  * over defaults. Useful for UIs that want to render a legend.
  */
-export function categoryColorPair(categoryKey, overrides = {}) {
+export function categoryColorPair(
+  categoryKey: string,
+  overrides: { byCategory?: Record<string, Partial<ColorPair>> } = {},
+): ColorPair | null {
   const def = categoryDefinition(categoryKey);
   if (!def) return null;
   const fromOverride = overrides.byCategory?.[categoryKey];
   const fromDefault = RELATION_COLOR_DEFAULTS.byCategory[categoryKey];
   if (!fromDefault && !fromOverride) return null;
-  return { ...(fromDefault ?? {}), ...(fromOverride ?? {}) };
+  return { ...(fromDefault ?? { light: '', dark: '' }), ...(fromOverride ?? {}) } as ColorPair;
 }
 
-function pickMode(pair, mode) {
+function pickMode(pair: ColorPair | string | null, mode: 'light' | 'dark'): string | null {
   if (pair == null) return null;
   if (typeof pair === 'string') return pair;
   return pair[mode] ?? pair.light ?? pair.dark ?? null;

package/src/models/section.ts

@@ -0,0 +1,61 @@
+import { GlossaristModel } from './base.js';
+import type { LocalizedString } from './generic-member.js';
+
+export const ORDERING_METHODS: ReadonlyArray<string> = Object.freeze([
+  'systematic',
+  'mixed',
+  'alphabetical',
+]);
+
+export type OrderingMethod = string;
+
+export interface SectionJson {
+  id?: string | null;
+  names?: LocalizedString;
+  ordering?: OrderingMethod | null;
+  children?: ReadonlyArray<SectionJson | Section>;
+}
+
+export class Section extends GlossaristModel {
+  readonly id: string | null;
+  readonly names: LocalizedString;
+  readonly ordering: OrderingMethod | null;
+  readonly children: ReadonlyArray<Section>;
+
+  constructor(data: SectionJson = {}) {
+    super();
+    this.id = data.id ?? null;
+    this.names = (data.names as LocalizedString) ?? {};
+    this.ordering = data.ordering ?? null;
+    this.children = (data.children ?? []).map((c) =>
+      c instanceof Section ? c : new Section(c as SectionJson),
+    );
+  }
+
+  name(lang: string): string | null {
+    return this.names[lang] ?? this.names['eng'] ?? null;
+  }
+
+  descendantById(id: string): Section | null {
+    for (const child of this.children) {
+      if (child.id === id) return child;
+      const found = child.descendantById(id);
+      if (found) return found;
+    }
+    return null;
+  }
+
+  override toJSON(): SectionJson {
+    const obj: SectionJson = { id: this.id };
+    if (Object.keys(this.names).length > 0) obj.names = { ...this.names };
+    if (this.ordering != null) obj.ordering = this.ordering;
+    if (this.children.length > 0) {
+      obj.children = this.children.map((c) => c.toJSON());
+    }
+    return obj;
+  }
+
+  static override fromJSON(data: SectionJson): Section {
+    return new Section(data);
+  }
+}