@kmanueldc/vue-odontogram 0.1.1

package/dist/components/Tooth.vue.d.ts

@@ -0,0 +1,56 @@
+import type { ToothDefinition, ToothState } from '../types/odontogram';
+import { type ToothNavigationKey } from '../utils/navigation';
+export interface ToothCondition {
+    fillColor?: string;
+    outlineColor?: string;
+}
+type __VLS_Props = {
+    tooth: ToothDefinition;
+    selected?: boolean;
+    disabled?: boolean;
+    condition?: ToothCondition;
+    /** Presentation transform supplied by the layout, after the shape's own. */
+    layoutTransform?: string;
+    /** Prefix of the accessible name, e.g. "Tooth" → "Tooth 11". */
+    label?: string;
+    /** Whether Tab reaches this tooth; a chart keeps a single tab stop. */
+    focusable?: boolean;
+    /** Presence status; it never changes selection or interaction. */
+    state?: ToothState;
+    /** Name of a non-present state, appended to the accessible name. */
+    stateLabel?: string;
+    /** Extra text appended to the accessible name, e.g. the tooth findings. */
+    description?: string;
+    /** Number shown in the title, in the chart's notation; the FDI ID by default. */
+    number?: string;
+    /** Number read in the accessible name; `number` by default. */
+    spokenNumber?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (tooth: ToothDefinition) => any;
+    mouseenter: (tooth: ToothDefinition, event: MouseEvent) => any;
+    mouseleave: (tooth: ToothDefinition, event: MouseEvent) => any;
+    focus: (tooth: ToothDefinition, event: FocusEvent) => any;
+    blur: (tooth: ToothDefinition, event: FocusEvent) => any;
+    navigate: (tooth: ToothDefinition, key: ToothNavigationKey) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((tooth: ToothDefinition) => any) | undefined;
+    onMouseenter?: ((tooth: ToothDefinition, event: MouseEvent) => any) | undefined;
+    onMouseleave?: ((tooth: ToothDefinition, event: MouseEvent) => any) | undefined;
+    onFocus?: ((tooth: ToothDefinition, event: FocusEvent) => any) | undefined;
+    onBlur?: ((tooth: ToothDefinition, event: FocusEvent) => any) | undefined;
+    onNavigate?: ((tooth: ToothDefinition, key: ToothNavigationKey) => any) | undefined;
+}>, {
+    number: string;
+    selected: boolean;
+    condition: ToothCondition;
+    state: ToothState;
+    label: string;
+    disabled: boolean;
+    spokenNumber: string;
+    layoutTransform: string;
+    focusable: boolean;
+    stateLabel: string;
+    description: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ToothInspector.vue.d.ts

@@ -0,0 +1,57 @@
+import type { FindingCatalog, OdontogramFinding } from '../types/findings';
+import type { OdontogramLabelsInput, OdontogramToothStates, ToothNotation } from '../types/odontogram';
+import { type SurfaceShapeKind, type ToothSurface } from '../types/surfaces';
+import { type SurfaceFindingRemoval, type ToothFindingInput } from '../utils/finding-records';
+/**
+ * Panel with everything recorded on one tooth: its surfaces (drawn with the
+ * surface guide), its findings by surface and on the whole tooth, and a form
+ * to add new ones. It holds no clinical rules and saves nothing: it emits
+ * `add-finding` and `remove-finding`, and the app decides what to record.
+ */
+type __VLS_Props = {
+    /** FDI ID of the tooth. */
+    toothId: string;
+    findings?: OdontogramFinding[];
+    findingCatalog?: FindingCatalog;
+    toothStates?: OdontogramToothStates;
+    labels?: OdontogramLabelsInput;
+    notation?: ToothNotation;
+    /** Shape of the surface diagram, like the chart's `surfaceShape`. */
+    shape?: SurfaceShapeKind;
+    /** Read-only panel: no adding or removing. */
+    disabled?: boolean;
+    /**
+     * Surfaces chosen for the next surface finding. Bind it with
+     * `v-model:selected-surfaces` to choose them from the chart too (e.g.
+     * `surfaces[toothId]` of the chart's `v-model:surfaces`); without it the
+     * panel keeps its own choice.
+     */
+    selectedSurfaces?: ToothSurface[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "add-finding": (input: ToothFindingInput) => any;
+    "remove-finding": (removal: SurfaceFindingRemoval) => any;
+    "update:selectedSurfaces": (surfaces: ToothSurface[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onAdd-finding"?: ((input: ToothFindingInput) => any) | undefined;
+    "onRemove-finding"?: ((removal: SurfaceFindingRemoval) => any) | undefined;
+    "onUpdate:selectedSurfaces"?: ((surfaces: ToothSurface[]) => any) | undefined;
+}>, {
+    findings: OdontogramFinding[];
+    labels: Partial<Omit<import("..").OdontogramLabels, "chartTitles" | "states" | "surfaceNames" | "surfaceLetters" | "surfaceDescriptions" | "findingStatuses" | "inspector"> & {
+        chartTitles: Partial<import("..").OdontogramLabels["chartTitles"]>;
+        states: Partial<import("..").OdontogramLabels["states"]>;
+        surfaceNames: Partial<import("..").OdontogramLabels["surfaceNames"]>;
+        surfaceLetters: Partial<import("..").OdontogramLabels["surfaceLetters"]>;
+        surfaceDescriptions: Partial<import("..").OdontogramLabels["surfaceDescriptions"]>;
+        findingStatuses: Partial<import("..").OdontogramLabels["findingStatuses"]>;
+        inspector: Partial<import("..").OdontogramLabels["inspector"]>;
+    }>;
+    disabled: boolean;
+    notation: ToothNotation;
+    toothStates: OdontogramToothStates;
+    findingCatalog: FindingCatalog;
+    shape: SurfaceShapeKind;
+    selectedSurfaces: ToothSurface[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/composables/useOdontogram.d.ts

@@ -0,0 +1,43 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { OdontogramCondition, OdontogramHalf, ToothNotation } from '../types/odontogram';
+import { type ToothAnchor } from '../utils/anchors';
+import type { RenderableDentition } from '../utils/dentition-layout';
+import type { OdontogramLayout } from '../utils/layout';
+import { type Box } from '../utils/svg-geometry';
+import type { FindingCatalog, OdontogramFinding } from '../types/findings';
+import type { SurfaceShapeKind } from '../types/surfaces';
+export interface OdontogramOptions {
+    dentition: MaybeRefOrGetter<RenderableDentition>;
+    layout: MaybeRefOrGetter<OdontogramLayout>;
+    notation: MaybeRefOrGetter<ToothNotation>;
+    conditions: MaybeRefOrGetter<readonly OdontogramCondition[] | undefined>;
+    showHalf?: MaybeRefOrGetter<OdontogramHalf>;
+    showNumbers?: MaybeRefOrGetter<boolean>;
+    findings?: MaybeRefOrGetter<readonly OdontogramFinding[] | undefined>;
+    findingCatalog?: MaybeRefOrGetter<FindingCatalog | undefined>;
+    showSurfaces?: MaybeRefOrGetter<boolean>;
+    /** Square (default) or circular surface diagrams. */
+    surfaceShape?: MaybeRefOrGetter<SurfaceShapeKind | undefined>;
+    /** FDI IDs of the teeth to draw; every tooth of the dentition when omitted. */
+    teeth?: MaybeRefOrGetter<readonly string[] | undefined>;
+}
+/**
+ * Resolves the dataset, composition, tooth definitions, anchors and number
+ * labels for a dentition and layout, limited to the visible arches.
+ */
+export declare function useOdontogram(options: OdontogramOptions): {
+    viewBox: import("vue").ComputedRef<string>;
+    viewBoxRect: import("vue").ComputedRef<Box>;
+    quadrants: import("vue").ComputedRef<{
+        teeth: import("../utils/compositions").ComposedTooth[];
+        quadrant: number;
+        transform: string;
+    }[]>;
+    anchors: import("vue").ComputedRef<Readonly<Record<string, ToothAnchor>>>;
+    anchorList: import("vue").ComputedRef<readonly ToothAnchor[]>;
+    numberLabels: import("vue").ComputedRef<import("../utils/numbers").ToothNumberLabel[]>;
+    surfaceDiagrams: import("vue").ComputedRef<import("..").SurfaceDiagram[]>;
+    findingLayout: import("vue").ComputedRef<import("../utils/findings").FindingLayout>;
+    findingsByTooth: import("vue").ComputedRef<Map<string, import("../utils/findings").RenderedFinding[]>>;
+    conditionByTooth: import("vue").ComputedRef<Map<string, OdontogramCondition>>;
+};

package/dist/composables/useToothSelection.d.ts

@@ -0,0 +1,11 @@
+import { type MaybeRefOrGetter } from 'vue';
+export interface ToothSelectionOptions {
+    modelValue: MaybeRefOrGetter<readonly string[] | undefined>;
+    singleSelect: MaybeRefOrGetter<boolean>;
+}
+/** Selection state derived from, and written back to, an Odontogram v-model. */
+export declare function useToothSelection(options: ToothSelectionOptions): {
+    isSelected: (id: string) => boolean;
+    selectedTeeth: import("vue").ComputedRef<string[]>;
+    toggle: (id: string) => string[];
+};

package/dist/data/index.d.ts

@@ -0,0 +1 @@
+export { permanentTeethPaths, type ToothShape, type ToothType, } from './permanent';

package/dist/data/permanent-horizontal.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Framework-independent SVG geometry for the permanent horizontal layout.
+ *
+ * Paths are ported verbatim from react-odontogram/src/data.ts::NewTeethPaths
+ * (MIT). They are a presentation alternative to permanentTeethPaths.
+ */
+import type { ToothShape } from './permanent';
+export declare const permanentHorizontalTeethPaths: ToothShape[];

package/dist/data/permanent.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Framework-independent SVG geometry for the eight permanent tooth positions.
+ *
+ * Paths are ported verbatim from react-odontogram/src/data.ts (MIT).
+ */
+import type { ToothShape } from '../types/geometry';
+export type { ToothShape, ToothType } from '../types/geometry';
+export declare const permanentTeethPaths: ToothShape[];

package/dist/data/primary-horizontal.d.ts

@@ -0,0 +1,19 @@
+import type { ToothShape } from '../types/geometry';
+/**
+ * Provisional pediatric geometry designed specifically for the horizontal
+ * composition. These original simplified paths are not clinically validated
+ * and must not be used for diagnostic or treatment purposes.
+ *
+ * Coordinates occupy the base half (x=18–246, y=14–64) of the tentative
+ * 520×180 workspace. The opposite side will be composed independently in
+ * the following layout phase.
+ */
+export declare const primaryHorizontalTeethPaths: ToothShape[];
+export declare const primaryHorizontalGeometryStatus: {
+    readonly status: "provisional";
+    readonly clinicallyValidated: false;
+    readonly intendedUse: "development-and-visual-review";
+    readonly source: "original-horizontal-prototype";
+    readonly scale: 0.75;
+    readonly targetGap: 12;
+};

package/dist/data/primary.d.ts

@@ -0,0 +1,14 @@
+import type { ToothShape } from '../types/geometry';
+/**
+ * Provisional pediatric geometry for development and visual iteration only.
+ *
+ * These SVG paths are simplified original approximations. They use the
+ * permanent arch as a coordinate reference but are not clinically validated
+ * and must not be used for diagnostic or treatment purposes.
+ */
+export declare const primaryTeethPaths: ToothShape[];
+export declare const primaryGeometryStatus: {
+    readonly status: "provisional";
+    readonly clinicallyValidated: false;
+    readonly intendedUse: "development-and-visual-review";
+};

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+export { default as Odontogram } from './components/Odontogram.vue';
+export { default as Tooth } from './components/Tooth.vue';
+export { default as SurfaceGuide } from './components/SurfaceGuide.vue';
+export { default as ToothInspector } from './components/ToothInspector.vue';
+export { buildToothId, formatToothNumber, getPalmerQuadrant, getToothType } from './utils/notation';
+export type { PalmerQuadrant } from './utils/notation';
+export { getQuadrant } from './utils/quadrants';
+export { defaultOdontogramLabels } from './utils/labels';
+export { toothStates } from './types/odontogram';
+export { ntsPeruFindingCatalog } from './catalogs/nts-peru';
+export type { NtsPeruFindingCode } from './catalogs/nts-peru';
+export { findingStatuses } from './types/findings';
+export { getFindingScope, resolveFindingTone } from './utils/findings';
+export type { FindingCatalog, FindingDefinition, FindingDirection, FindingScope, FindingStatus, FindingSymbol, FindingSymbolKind, FindingTone, OdontogramFinding, } from './types/findings';
+export { surfaceShapeKinds, toothSurfaces } from './types/surfaces';
+export type { OdontogramSurfaces, SurfaceShapeKind, ToothSurface, ToothSurfaceName } from './types/surfaces';
+export { getSurfaceName, toggleSurface } from './utils/surfaces';
+export type { SurfaceDiagram, SurfaceShape } from './utils/surfaces';
+export { addFinding, addSurfaceFinding, getToothRecord, removeSurfaceFinding } from './utils/finding-records';
+export type { SurfaceFindingInput, SurfaceFindingRemoval, ToothFindingInput, ToothFindingEntry, ToothRecord, } from './utils/finding-records';
+export { getToothAnchors, getLayoutViewBox } from './utils/anchors';
+export type { Box, Point, ToothAnchor } from './utils/anchors';
+export type { DentalArch, DentalSide, Dentition, OdontogramCondition, OdontogramHalf, OdontogramLabels, OdontogramLabelsInput, OdontogramToothStates, ToothDefinition, ToothNotation, ToothShape, ToothState, ToothType, ToothVisualCondition, } from './types/odontogram';
+export type { OdontogramLayout } from './utils/layout';
+export type { ToothCondition } from './components/Tooth.vue';
+export type { TooltipPlacement } from './components/OdontogramTooltip.vue';

package/dist/types/findings.d.ts

@@ -0,0 +1,154 @@
+import type { ToothSurface } from './surfaces';
+/**
+ * Default color of a finding. Following the common charting convention
+ * (e.g. Peru's NTS odontogram standard): `good` is drawn in blue (good state
+ * or completed treatment) and `bad` in red (bad state or pending).
+ */
+export type FindingTone = 'good' | 'bad';
+/**
+ * Where a finding stands in the treatment workflow. The library only draws it;
+ * clinical rules (what can be planned, when it is done) belong to the app.
+ * - `existing`: found in the mouth, e.g. a caries or a previous restoration.
+ * - `planned`: a treatment to do; drawn with dashed strokes and a lighter fill.
+ * - `done`: a treatment performed.
+ */
+export type FindingStatus = 'existing' | 'planned' | 'done';
+export declare const findingStatuses: readonly FindingStatus[];
+/** Direction of a finding along the arch. */
+export type FindingDirection = 'mesial' | 'distal';
+/**
+ * How a finding is drawn. The kind also fixes how many teeth it uses:
+ * - surfaces of the surface diagram, per listed tooth: `fill`, `outline`;
+ * - single tooth, one symbol per listed tooth: `line`, `cross`, `circle`,
+ *   `double-circle`, `triangle`, `arrow`, `curved-arrow`, `zigzag`, `text`,
+ *   `encircled-text`;
+ * - between two teeth: `diastema`, `transposition`;
+ * - a range of teeth of one arch, from the first to the last listed tooth:
+ *   `bridge`, `double-line`, `brackets`, `zigzag-line`, `center-line`.
+ */
+export type FindingSymbol = 
+/** Fills the finding's surfaces in the surface diagram, e.g. a caries or a restoration. */
+{
+    kind: 'fill';
+}
+/** Outlines the finding's surfaces in the surface diagram, e.g. a temporary restoration. */
+ | {
+    kind: 'outline';
+}
+/** A straight line across the tooth, e.g. a fracture. */
+ | {
+    kind: 'line';
+}
+/** An "X" across the tooth, e.g. an extraction. */
+ | {
+    kind: 'cross';
+}
+/** A circle around the tooth, e.g. a crown. */
+ | {
+    kind: 'circle';
+}
+/** Two overlapping circles, e.g. fusion. */
+ | {
+    kind: 'double-circle';
+}
+/** A triangle over the tooth, e.g. a peg-shaped tooth. */
+ | {
+    kind: 'triangle';
+}
+/**
+ * A straight arrow across the tooth. `occlusal` points to the other arch,
+ * `apical` away from it; `mesial`/`distal` follow the arch, and `auto`
+ * uses the finding's `direction` (mesial by default).
+ */
+ | {
+    kind: 'arrow';
+    direction: 'occlusal' | 'apical' | 'mesial' | 'distal' | 'auto';
+}
+/** A curved arrow over the tooth, e.g. rotation. */
+ | {
+    kind: 'curved-arrow';
+}
+/** A zigzag arrow toward the other arch, e.g. an erupting tooth. */
+ | {
+    kind: 'zigzag';
+}
+/** An abbreviation on the vestibular side of the tooth, e.g. `IMP`. */
+ | {
+    kind: 'text';
+    text: string;
+}
+/** An abbreviation inside a circle, e.g. `S` for a supernumerary tooth. */
+ | {
+    kind: 'encircled-text';
+    text: string;
+}
+/** Facing arcs `)(` between two teeth. */
+ | {
+    kind: 'diastema';
+}
+/** Crossed arrows between two teeth. */
+ | {
+    kind: 'transposition';
+}
+/** A line with end caps along a range of teeth, e.g. a fixed prosthesis. */
+ | {
+    kind: 'bridge';
+}
+/** Two parallel lines along a range of teeth, e.g. a removable prosthesis. */
+ | {
+    kind: 'double-line';
+}
+/** A line with a bracket on each tooth, e.g. a fixed orthodontic appliance. */
+ | {
+    kind: 'brackets';
+}
+/** A zigzag line along a range of teeth, e.g. a removable orthodontic appliance. */
+ | {
+    kind: 'zigzag-line';
+}
+/** A line through the teeth centers, e.g. an edentulous arch. */
+ | {
+    kind: 'center-line';
+};
+export type FindingSymbolKind = FindingSymbol['kind'];
+export type FindingScope = 'surface' | 'tooth' | 'between' | 'span';
+/** A catalog entry: how a finding code is named and drawn. */
+export interface FindingDefinition {
+    /** Display name for tooltip, legend and accessible names. */
+    name: string;
+    symbol: FindingSymbol;
+    /** Color used when a finding sets neither `tone` nor `color`. */
+    tone: FindingTone;
+}
+/** Finding definitions keyed by code. */
+export type FindingCatalog = Readonly<Record<string, FindingDefinition>>;
+/** A finding recorded on the chart. */
+export interface OdontogramFinding {
+    /** Catalog code, e.g. `fracture`. */
+    code: string;
+    /**
+     * FDI IDs. Surface and single-tooth findings draw one symbol per tooth;
+     * `between` findings use two teeth; `span` findings cover the arch range
+     * from the first to the last listed tooth.
+     */
+    teeth: string[];
+    /**
+     * Surfaces of surface findings (`fill`, `outline`); every surface when
+     * omitted. Other findings ignore it.
+     */
+    surfaces?: ToothSurface[];
+    /** Workflow status; `existing` by default. */
+    status?: FindingStatus;
+    /**
+     * Overrides the default color. Without it, `planned` findings are `bad`
+     * (red), `done` findings are `good` (blue) and `existing` ones use the
+     * catalog tone.
+     */
+    tone?: FindingTone;
+    /** Any CSS color; overrides `tone`. */
+    color?: string;
+    /** Overrides the abbreviation of text symbols, e.g. `M2` for mobility. */
+    label?: string;
+    /** Direction for arrows whose catalog direction is `auto`, e.g. migration. */
+    direction?: FindingDirection;
+}

package/dist/types/geometry.d.ts

@@ -0,0 +1,18 @@
+/** Tooth categories represented by the permanent dataset. */
+export type PermanentToothType = 'Central Incisor' | 'Lateral Incisor' | 'Canine' | 'First Premolar' | 'Second Premolar' | 'First Molar' | 'Second Molar' | 'Third Molar';
+/** Tooth categories required by a clinically correct primary dataset. */
+export type PrimaryToothType = 'Primary Central Incisor' | 'Primary Lateral Incisor' | 'Primary Canine' | 'Primary First Molar' | 'Primary Second Molar';
+export type ToothType = PermanentToothType | PrimaryToothType;
+/**
+ * Reusable SVG geometry. It intentionally contains no dentition, quadrant,
+ * notation, selection or framework concerns.
+ */
+export interface ToothShape {
+    position: number;
+    type: ToothType;
+    outlinePath: string;
+    shadowPath?: string;
+    lineHighlightPath?: string | string[];
+    /** Optional local SVG transform intrinsic to this geometry. */
+    transform?: string;
+}

package/dist/types/odontogram.d.ts

@@ -0,0 +1,119 @@
+import type { ToothShape, ToothType } from './geometry';
+import type { FindingStatus } from './findings';
+import type { ToothSurfaceName } from './surfaces';
+/** The set of dentitions the library can represent. */
+export type Dentition = 'permanent' | 'primary' | 'mixed';
+/** Dental numbering systems supported by the public API. */
+export type ToothNotation = 'FDI' | 'Universal' | 'Palmer';
+export type DentalArch = 'upper' | 'lower';
+export type DentalSide = 'left' | 'right';
+/** Which arches an odontogram shows: both, or only one of them. */
+export type OdontogramHalf = 'full' | DentalArch;
+/**
+ * A tooth in a chart. It connects its clinical position to a reusable SVG
+ * shape, without placing rendering concerns in the data model.
+ */
+export interface ToothDefinition {
+    id: string;
+    position: number;
+    quadrant: number;
+    dentition: Dentition;
+    type: ToothType;
+    shape: ToothShape;
+}
+/**
+ * Presence status of a tooth. It is independent of selection and conditions:
+ * - `present`: the tooth is in the mouth (default).
+ * - `missing`: absent, e.g. agenesis or unknown cause.
+ * - `extracted`: removed.
+ * - `implant`: replaced by an implant.
+ * - `unerupted`: not yet erupted.
+ */
+export type ToothState = 'present' | 'missing' | 'extracted' | 'implant' | 'unerupted';
+export declare const toothStates: readonly ToothState[];
+/** Tooth states keyed by FDI ID; unlisted teeth are `present`. */
+export type OdontogramToothStates = Partial<Record<string, ToothState>>;
+/** Colors and legend text applied to a tooth. */
+export interface ToothVisualCondition {
+    label?: string;
+    fillColor?: string;
+    outlineColor?: string;
+}
+/**
+ * A visual condition applied to a group of FDI teeth. A tooth shows a single
+ * condition: when it appears in several groups, the last group wins.
+ */
+export interface OdontogramCondition extends ToothVisualCondition {
+    teeth: string[];
+}
+/** User-facing text rendered by the odontogram, tooltip and legend. */
+export interface OdontogramLabels {
+    /** Accessible name of the whole chart container. */
+    odontogram: string;
+    /** Title and accessible name of the SVG, per dentition. */
+    chartTitles: Record<Dentition, string>;
+    /** Prefix of each tooth's accessible name, e.g. "Tooth 11". */
+    tooth: string;
+    type: string;
+    selected: string;
+    yes: string;
+    no: string;
+    condition: string;
+    /** Accessible name of the condition legend. */
+    legend: string;
+    /** Display names per tooth type; missing entries show the type itself. */
+    toothTypes: Partial<Record<ToothType, string>>;
+    /** Prefix of the tooth state line in the tooltip. */
+    state: string;
+    /** Display names per tooth state. */
+    states: Record<ToothState, string>;
+    /** Prefix of the findings line in the tooltip. */
+    findings: string;
+    /** Finding statuses, shown after planned and done findings. */
+    findingStatuses: Record<FindingStatus, string>;
+    /** Accessible name of the surface diagrams layer. */
+    surfaces: string;
+    /** Prefix of the surface line in the tooltip of a surface. */
+    surface: string;
+    /** Heading of the per-surface summary in the tooltip of a tooth. */
+    surfaceSummary: string;
+    /** Clinical surface names, e.g. "Tooth 11, Incisal". */
+    surfaceNames: Record<ToothSurfaceName, string>;
+    /** One-letter surface codes drawn on diagrams, e.g. `M` or `P`. */
+    surfaceLetters: Record<ToothSurfaceName, string>;
+    /** What each surface is, shown by the surface guide. */
+    surfaceDescriptions: Record<ToothSurfaceName, string>;
+    /** Accessible name of the surface guide. */
+    surfaceGuide: string;
+    /** Accessible name of the surface menu, e.g. "Surface findings: Tooth 16, Occlusal". */
+    surfaceMenu: string;
+    /** Texts of the tooth inspector panel. */
+    inspector: {
+        /** Accessible name of the panel, followed by the tooth. */
+        title: string;
+        surfaceFindings: string;
+        toothFindings: string;
+        noFindings: string;
+        addFinding: string;
+        finding: string;
+        status: string;
+        add: string;
+        remove: string;
+        /** Hint shown until surfaces are chosen for a surface finding. */
+        chooseSurfaces: string;
+        /** Option groups of the finding list. */
+        onSurfaces: string;
+        onTooth: string;
+    };
+}
+/** Labels override where nested maps can also be partially replaced. */
+export type OdontogramLabelsInput = Partial<Omit<OdontogramLabels, 'chartTitles' | 'states' | 'surfaceNames' | 'surfaceLetters' | 'surfaceDescriptions' | 'findingStatuses' | 'inspector'> & {
+    chartTitles: Partial<OdontogramLabels['chartTitles']>;
+    states: Partial<OdontogramLabels['states']>;
+    surfaceNames: Partial<OdontogramLabels['surfaceNames']>;
+    surfaceLetters: Partial<OdontogramLabels['surfaceLetters']>;
+    surfaceDescriptions: Partial<OdontogramLabels['surfaceDescriptions']>;
+    findingStatuses: Partial<OdontogramLabels['findingStatuses']>;
+    inspector: Partial<OdontogramLabels['inspector']>;
+}>;
+export type { ToothShape, ToothType };

package/dist/types/surfaces.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The five crown surfaces of a tooth. The keys are the same for every tooth;
+ * the clinical name adapts to it (see `getSurfaceName`):
+ * - `occlusal` is incisal on incisors and canines;
+ * - `lingual` is palatal on upper teeth;
+ * - `vestibular` faces the lips or cheeks (buccal/labial).
+ */
+export type ToothSurface = 'mesial' | 'distal' | 'occlusal' | 'vestibular' | 'lingual';
+/** Every surface, in the order they are listed in the model and read aloud. */
+export declare const toothSurfaces: readonly ToothSurface[];
+/** Clinical name of a surface on a given tooth. */
+export type ToothSurfaceName = ToothSurface | 'incisal' | 'palatal';
+/**
+ * How the five-surface diagram is drawn:
+ * - `square`: a square with a central occlusal square and four trapezoids.
+ * - `circle`: a circle with a central occlusal circle and four ring sectors.
+ */
+export type SurfaceShapeKind = 'square' | 'circle';
+export declare const surfaceShapeKinds: readonly SurfaceShapeKind[];
+/** Selected surfaces keyed by FDI ID; unlisted teeth have none. */
+export type OdontogramSurfaces = Partial<Record<string, ToothSurface[]>>;

package/dist/utils/anchors.d.ts

@@ -0,0 +1,37 @@
+import type { DentalArch } from '../types/odontogram';
+import type { RenderableDentition } from './dentition-layout';
+import type { OdontogramLayout } from './layout';
+import type { NumberedDentition } from './quadrants';
+import { type Box, type Point } from './svg-geometry';
+export type { Box, Point };
+/**
+ * A row of teeth drawn along one arch, e.g. `upper-primary`. Permanent and
+ * primary charts have one row per arch; mixed charts have two.
+ */
+export type ToothRow = `${DentalArch}-${NumberedDentition}`;
+/**
+ * Where a tooth is drawn, in the SVG coordinates of its layout's viewBox.
+ * Overlays such as numbers, symbols or surface diagrams can be positioned
+ * from it without reading the DOM.
+ */
+export interface ToothAnchor {
+    toothId: string;
+    quadrant: number;
+    arch: DentalArch;
+    dentition: NumberedDentition;
+    row: ToothRow;
+    /** Axis-aligned bounding box of the tooth outline. */
+    box: Box;
+    /** Center of `box`. */
+    center: Point;
+}
+/** Parses a `viewBox` attribute. */
+export declare function parseViewBox(viewBox: string): Box;
+/**
+ * Computes the anchor of every tooth for a dentition and layout, in render
+ * order. It composes the quadrant, shape and layout transforms exactly as the
+ * SVG does, so the result matches the rendered position.
+ */
+export declare function getToothAnchors(dentition: RenderableDentition, layout: OdontogramLayout): readonly ToothAnchor[];
+/** Returns the parsed viewBox of a dentition and layout. */
+export declare function getLayoutViewBox(dentition: RenderableDentition, layout: OdontogramLayout): Box;

package/dist/utils/compositions.d.ts

@@ -0,0 +1,41 @@
+import type { ToothDefinition, ToothShape, ToothType } from '../types/odontogram';
+import type { RenderableDentition } from './dentition-layout';
+import { type OdontogramLayout } from './layout';
+import type { NumberedDentition } from './quadrants';
+/** The teeth of one dataset in a composition. */
+export interface CompositionPart {
+    dentition: NumberedDentition;
+    quadrants: readonly {
+        quadrant: number;
+        transform: string;
+    }[];
+    shapes: readonly ToothShape[];
+    /** Presentation offsets per tooth type, applied after the shape transform. */
+    toothTransforms?: Readonly<Partial<Record<ToothType, string>>>;
+}
+/**
+ * Everything needed to draw one dentition in one layout. Permanent and
+ * primary compositions have one part; mixed ones combine both datasets.
+ */
+export interface DentitionComposition {
+    viewBox: string;
+    parts: readonly CompositionPart[];
+}
+export declare function getComposition(dentition: RenderableDentition, layout: OdontogramLayout): DentitionComposition;
+export interface ComposedTooth {
+    tooth: ToothDefinition;
+    /** Layout-specific transform for this tooth, if any. */
+    transform?: string;
+}
+export interface ComposedQuadrant {
+    quadrant: number;
+    transform: string;
+    teeth: ComposedTooth[];
+}
+/**
+ * Builds the FDI teeth of a composition, grouped in render order. Tooth IDs
+ * are always FDI, independent of the presentation.
+ */
+export declare function composeQuadrants(dentition: RenderableDentition, layout: OdontogramLayout): ComposedQuadrant[];
+/** FDI IDs of every tooth a dentition can draw, in render order. */
+export declare function getDentitionToothIds(dentition: RenderableDentition, layout: OdontogramLayout): string[];