@auditcore/ui-core 0.3.0

package/dist/geo/types.d.ts

@@ -0,0 +1,195 @@
+/** Typen des REST-Vertrags `docs/ui/geo-rest.md` (auditcore_geo.web). */
+export interface LatLon {
+    lat: number;
+    lon: number;
+}
+/** GeoJSON-Fläche in Achsenfolge Länge, Breite (RFC 7946). */
+export type AreaGeometry = {
+    type: 'Polygon';
+    coordinates: number[][][];
+} | {
+    type: 'MultiPolygon';
+    coordinates: number[][][][];
+};
+/** Punkt auf der Karte (z. B. Vorhabenstandort); `id` ist die Kennung in Ergebnissen. */
+export interface GeoPoint extends LatLon {
+    id: string;
+    label?: string | null;
+}
+/** Fläche auf der Karte (z. B. Schutzgebiet); `notes` sind Hinweise zur Geometrie. */
+export interface GeoArea {
+    id: string;
+    label?: string | null;
+    geometry: AreaGeometry;
+    notes?: readonly string[];
+}
+/** Kachelquelle der Anwendung; ohne Quelle zeigt die Karte keinen Hintergrund. */
+export interface TileSource {
+    /** URL-Vorlage mit `{z}`, `{x}`, `{y}` (optional `{s}`). */
+    url: string;
+    /** Pflichtnennung der Kachel- und Kartendaten, wird immer angezeigt. */
+    attribution: string;
+    maxZoom?: number;
+    subdomains?: string;
+}
+export interface EarthModel {
+    id: string;
+    radius_m: number;
+    beschreibung: string;
+    empfohlen: boolean;
+}
+export interface GeoCatalogue {
+    bibliothek: string;
+    erdmodelle: readonly EarthModel[];
+    empfohlenes_erdmodell: string;
+    rand_gilt_als_innen_empfohlen: boolean;
+    ellipsoide: readonly string[];
+    vereinfachung_einheiten: readonly ('meter' | 'grad')[];
+    grenzen: {
+        max_body_bytes: number;
+        max_punkte: number;
+        max_stuetzpunkte: number;
+        max_gpkg_bytes: number;
+        max_gpkg_flaechen: number;
+    };
+    geocoder: {
+        aktiv: boolean;
+        namensnennung: string | null;
+    };
+    gpkg_quellen: readonly string[];
+}
+export interface RadiusRequest {
+    zentrum: LatLon;
+    punkte: readonly (LatLon & {
+        id: string;
+    })[];
+    radius_m: number;
+    erdmodell: string;
+}
+export interface RadiusHit {
+    index: number;
+    id: string;
+    abstand_m: number;
+}
+export interface RadiusResult {
+    erdmodell: string;
+    radius_m: number;
+    geprueft: number;
+    treffer: readonly RadiusHit[];
+}
+export type Position = 'innen' | 'aussen' | 'rand';
+export interface LocateRequest {
+    punkt: LatLon;
+    flaeche: AreaGeometry;
+    erdmodell: string;
+    rand_gilt_als_innen: boolean;
+    rand_toleranz_m?: number;
+}
+export interface DegenerateRing {
+    polygon: number;
+    ring: number;
+    art: 'punkt' | 'linie';
+    rolle: 'aussen' | 'loch';
+    hinweis: string;
+}
+export interface LocateResult {
+    lage: Position;
+    lage_mit_toleranz: Position;
+    rand_toleranz_m: number;
+    rand_gilt_als_innen: boolean;
+    enthaelt: boolean;
+    abstand_m: number;
+    erdmodell: string;
+    entarteter_ring: DegenerateRing | null;
+    hinweise: readonly string[];
+}
+export interface UtmRequest {
+    punkt: LatLon;
+    ellipsoid: string;
+    zone?: number;
+}
+export interface UtmResult {
+    zone: number;
+    nordhalbkugel: boolean;
+    ellipsoid: string;
+    epsg: number | null;
+    mittelmeridian: number;
+    ost: number;
+    nord: number;
+}
+/** `POST /utm/geographisch`: Punkt aus Rechts-/Hochwert, Zone und Halbkugel. */
+export interface UtmPointRequest {
+    ost: number;
+    nord: number;
+    zone: number;
+    nordhalbkugel: boolean;
+    ellipsoid: string;
+}
+export interface UtmPointResult {
+    punkt: LatLon;
+    zone: number;
+}
+export type SimplifyUnit = 'meter' | 'grad';
+export interface SimplifyRequest {
+    flaeche: AreaGeometry;
+    toleranz: number;
+    einheit: SimplifyUnit;
+    stellen?: number;
+}
+export interface SimplifyResult {
+    geometrie: AreaGeometry | null;
+    stuetzpunkte_vorher: number;
+    stuetzpunkte_nachher: number;
+    entfallene_ringe: readonly {
+        polygon: number;
+        ring: number;
+    }[];
+    einheit: SimplifyUnit;
+    toleranz: number;
+    utm_zone: number | null;
+}
+export interface GeoPackageArea {
+    id: string;
+    bezeichnung: string | null;
+    geometrie: AreaGeometry;
+    hinweise: readonly string[];
+}
+export interface GeoPackageResult {
+    quelle?: string;
+    tabellen: readonly string[];
+    tabelle: string;
+    srs_id: number;
+    umgerechnet: boolean;
+    flaechen: readonly GeoPackageArea[];
+    fehler: readonly {
+        id: string;
+        meldung: string;
+    }[];
+    abgeschnitten: boolean;
+}
+export interface GeocodeHit extends LatLon {
+    rang: number;
+    anzeigename: string | null;
+}
+export interface GeocodeResult {
+    treffer: readonly GeocodeHit[];
+    namensnennung: string;
+}
+/**
+ * Schnittstelle der Komponente zur Fachlogik; Standardumsetzung:
+ * `createGeoRestPort`. Optionale Methoden fehlen, wenn die Anwendung die
+ * Funktion nicht anbietet – die Oberfläche blendet sie dann aus.
+ * `geocode` (Adresssuche) gibt es nur auf ausdrücklichen Wunsch.
+ */
+export interface GeoPort {
+    catalogue(): Promise<GeoCatalogue>;
+    radius(request: RadiusRequest): Promise<RadiusResult>;
+    locate(request: LocateRequest): Promise<LocateResult>;
+    utm(request: UtmRequest): Promise<UtmResult>;
+    /** Rückrechnung aus UTM; ohne sie blendet die Oberfläche die UTM-Eingabe aus. */
+    fromUtm?(request: UtmPointRequest): Promise<UtmPointResult>;
+    simplify(request: SimplifyRequest): Promise<SimplifyResult>;
+    loadGeoPackage?(file: Blob, table?: string): Promise<GeoPackageResult>;
+    loadSource?(name: string, table?: string): Promise<GeoPackageResult>;
+    geocode?(query: string): Promise<GeocodeResult>;
+}

package/dist/i18n.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Framework-freier Kern der Sprachunterstützung: Kataloge, Platzhalter,
+ * Rückfall auf Deutsch. Vue (`useI18n` in `@auditcore/ui`) und React
+ * (`useTranslation` in `@auditcore/ui-react`) setzen darauf auf.
+ */
+export type Locale = 'de' | 'en';
+export declare const LOCALES: readonly Locale[];
+export declare const DEFAULT_LOCALE: Locale;
+export type MessageParams = Readonly<Record<string, string | number>>;
+/** Kataloge je Sprache; Deutsch ist vollständig, Englisch darf (noch) lückenhaft sein. */
+export interface Catalogs<K extends string> {
+    de: Readonly<Record<K, string>>;
+    en: Readonly<Partial<Record<K, string>>>;
+}
+export type Translate<K extends string> = (key: K, params?: MessageParams) => string;
+/** Typisiert Kataloge einer Komponente; die Schlüssel ergeben sich aus dem deutschen Katalog. */
+export declare function defineMessages<K extends string>(catalogs: Catalogs<K>): Catalogs<K>;
+/** Ersetzt {name}-Platzhalter; unbekannte Platzhalter bleiben sichtbar stehen. */
+export declare function interpolate(template: string, params?: MessageParams): string;
+/** Übersetzt mit Rückfall auf Deutsch und zuletzt auf den Schlüssel. */
+export declare function translate<K extends string>(catalogs: Catalogs<K>, locale: Locale, key: K, params?: MessageParams): string;
+/** Übersetzungsfunktion für eine feste Sprache. */
+export declare function translator<K extends string>(catalogs: Catalogs<K>, locale: Locale): Translate<K>;
+export declare function isLocale(value: unknown): value is Locale;
+/** Sprache ohne Provider (Web Components, React ohne `LocaleProvider`). */
+export declare function setDefaultLocale(locale: Locale): void;
+export declare function getDefaultLocale(): Locale;
+/** Meldet Änderungen der Standardsprache; liefert die Abmeldung. */
+export declare function subscribeDefaultLocale(listener: () => void): () => void;

package/dist/identifiers/controller.d.ts

@@ -0,0 +1,63 @@
+import { RequestState, Store } from '../store';
+import { TableImportData } from '../tabular';
+import { IdentifierBatchMapping, IdentifierColumn, IdentifierError } from './model';
+import { IdentifierBatchAnswer, IdentifierBatchRequest, IdentifierCatalogue, IdentifierResult, IdentifiersPort } from './types';
+export type IdentifierBusy = 'load' | 'check' | 'batch';
+export interface IdentifierCallbacks {
+    checked?: (result: IdentifierResult) => void;
+    batchChecked?: (answer: IdentifierBatchAnswer) => void;
+    failed?: (message: string) => void;
+}
+export interface IdentifierData extends RequestState<string> {
+    catalogue: IdentifierCatalogue | null;
+    profileId: string | null;
+    kind: string | null;
+    value: string;
+    country: string;
+    result: IdentifierResult | null;
+    validation: IdentifierError | null;
+    /** Kennungsart aller Tabellenzeilen; `null` = aus `kindColumn`. */
+    batchKind: string | null;
+    kindColumn: number | null;
+    countryColumn: number | null;
+    batchRequest: IdentifierBatchRequest | null;
+    batch: IdentifierBatchAnswer | null;
+    batchValidation: IdentifierError | null;
+    onlyIssues: boolean;
+}
+export declare const INITIAL_IDENTIFIERS: IdentifierData;
+/** Einfache Eingabefelder, die die Oberfläche direkt setzen darf. */
+export type IdentifierField = 'value' | 'country' | 'kindColumn' | 'countryColumn' | 'onlyIssues';
+export interface IdentifierSource {
+    port: () => IdentifiersPort | null | undefined;
+    callbacks?: () => IdentifierCallbacks;
+}
+/** Zuordnung aus beiden Zuständen (Tabelle und Kennungsprüfung). */
+export declare function identifierBatchMapping(state: IdentifierData, loaded: TableImportData): IdentifierBatchMapping;
+export declare function createIdentifierController(source: IdentifierSource): {
+    /** Spalte zuordnen; `null` = keine (nur optionale Spalten). */
+    setColumn: (column: IdentifierColumn, index: number | null) => void;
+    setHasHeader: (hasHeader: boolean) => void;
+    readFile: (file: File) => Promise<void>;
+    store: Store<IdentifierData>;
+    /** Datei-Import (gemeinsamer TableImport-Controller aus `@auditcore/ui-core`). */
+    table: {
+        store: Store<TableImportData>;
+        load: (filename: string, text: string) => void;
+        reparse: () => void;
+        read: (file: File) => Promise<void>;
+        setHasHeader: (hasHeader: boolean) => void;
+        setValueColumn: (valueColumn: number) => void;
+        setIdColumn: (idColumn: number | null) => void;
+        setStratumColumn: (stratumColumn: number | null) => void;
+        setDecimal: (decimal: import('@auditcore/common').DecimalSeparator) => void;
+    };
+    load: () => Promise<void>;
+    check: () => Promise<void>;
+    checkBatch: () => Promise<void>;
+    setProfile: (profileId: string | null) => void;
+    setKind: (kind: string | null) => void;
+    setBatchKind: (batchKind: string | null) => void;
+    setField: <K extends IdentifierField>(key: K, value: IdentifierData[K]) => void;
+};
+export type IdentifierController = ReturnType<typeof createIdentifierController>;

package/dist/identifiers/index.d.ts

@@ -0,0 +1,5 @@
+export { identifierMessages, type IdentifierMessageKey } from './messages';
+export * from './model';
+export { createIdentifiersRestPort } from './rest-port';
+export type * from './types';
+export * from './controller';

package/dist/identifiers/messages.d.ts

@@ -0,0 +1,3 @@
+/** Texte von „Kennung prüfen“. */
+export declare const identifierMessages: import('..').Catalogs<"loading" | "header" | "message" | "details" | "summary" | "title" | "check" | "reason" | "value" | "none" | "profile" | "kind" | "noPort" | "yes" | "no" | "colStatus" | "result" | "export" | "failed" | "choose" | "recommended" | "normalized" | "country" | "file" | "valueColumn" | "colValue" | "errortooMany" | "errorprofile" | "profileSource" | "single" | "legacy" | "countryHelp" | "statusVALID" | "statusINVALID" | "statusMISSING" | "validText" | "countryFound" | "batch" | "batchHelp" | "tableSummary" | "kindSource" | "fromColumn" | "kindColumn" | "refColumn" | "countryColumn" | "batchRun" | "colRef" | "colKind" | "colReason" | "colNormalized" | "notChecked" | "onlyInvalid" | "lineRef" | "errorkind" | "errornoTable" | "errornoRows" | "errorkindColumn">;
+export type IdentifierMessageKey = keyof typeof identifierMessages.de;

package/dist/identifiers/model.d.ts

@@ -0,0 +1,87 @@
+import { ParsedTable } from '@auditcore/common';
+import { Translate } from '../i18n';
+import { IdentifierMessageKey } from './messages';
+import { IdentifierBatchAnswer, IdentifierBatchRequest, IdentifierBatchRow, IdentifierCheckRequest, IdentifierCatalogue, IdentifierKindInfo, IdentifierProfileInfo, IdentifierResult, IdentifierStatus } from './types';
+export type IdentifierTranslate = Translate<IdentifierMessageKey>;
+export type IdentifierError = 'kind' | 'profile' | 'noTable' | 'noRows' | 'tooMany' | 'kindColumn';
+export type IdentifierValidation<R> = {
+    ok: true;
+    request: R;
+} | {
+    ok: false;
+    error: IdentifierError;
+};
+export declare function findIdentifierProfile(catalogue: IdentifierCatalogue | null, id: string | null): IdentifierProfileInfo | null;
+/** Kennungsarten, die das gewählte Profil prüft (ohne Profil: keine). */
+export declare function identifierProfileKinds(catalogue: IdentifierCatalogue | null, profileId: string | null): IdentifierKindInfo[];
+/** Anzeige eines Profils in der Auswahl: Empfehlung und Altverhalten sichtbar. */
+export declare function identifierProfileLabel(catalogue: IdentifierCatalogue, profile: IdentifierProfileInfo, t: IdentifierTranslate): string;
+export declare function kindNeedsCountry(catalogue: IdentifierCatalogue | null, kind: string | null): boolean;
+export interface IdentifierCheckInput {
+    catalogue: IdentifierCatalogue;
+    profile: string | null;
+    kind: string | null;
+    value: string;
+    country: string;
+}
+/** Anfrage für `POST /check`; Profil und Kennungsart sind Pflicht, ein leerer Wert ergibt „fehlt“. */
+export declare function buildIdentifierCheck(input: IdentifierCheckInput): IdentifierValidation<IdentifierCheckRequest>;
+/** Kennungsart aus einer Tabellenzelle: Kennung oder Bezeichnung des Katalogs, sonst unverändert (Server meldet sie). */
+export declare function resolveIdentifierKind(catalogue: IdentifierCatalogue, cell: string): string;
+export interface IdentifierBatchMapping {
+    table: ParsedTable | null;
+    hasHeader: boolean;
+    valueColumn: number;
+    refColumn: number | null;
+    /** Kennungsart für alle Zeilen; `null` = aus `kindColumn`. */
+    kind: string | null;
+    kindColumn: number | null;
+    countryColumn: number | null;
+}
+/** Anfrage für `POST /check/batch` aus der geladenen Tabelle und der Spaltenzuordnung. */
+export declare function buildIdentifierBatch(catalogue: IdentifierCatalogue, profile: string | null, mapping: IdentifierBatchMapping): IdentifierValidation<IdentifierBatchRequest>;
+export declare function identifierErrorKey(error: IdentifierError): IdentifierMessageKey;
+export type IdentifierTone = 'success' | 'danger' | 'warning' | 'neutral';
+export declare function identifierStatusTone(status: IdentifierStatus | null): IdentifierTone;
+export declare function identifierStatusText(status: IdentifierStatus | null, t: IdentifierTranslate): string;
+/** Begründung eines Ergebnisses: Meldung der Bibliothek, bei „gültig“ der Satz zum Profil. */
+export declare function identifierReasonText(result: IdentifierResult, profileTitle: string, t: IdentifierTranslate): string;
+/** Einzelheiten (`details`) mit deutschen Bezeichnungen aus dem Katalog. */
+export declare function identifierFacts(catalogue: IdentifierCatalogue, result: IdentifierResult, t: IdentifierTranslate): {
+    key: string;
+    label: string;
+    value: string;
+}[];
+/** Status einer Stapelzeile; `null` = nicht prüfbar. */
+export declare function identifierRowStatus(row: IdentifierBatchRow): IdentifierStatus | null;
+/** Begründung einer Stapelzeile; gültige Zeilen nur mit eigener Meldung der Bibliothek (Tabelle bleibt knapp). */
+export declare function identifierRowReason(row: IdentifierBatchRow): string;
+export declare function identifierRowKind(catalogue: IdentifierCatalogue, row: IdentifierBatchRow, request: IdentifierBatchRequest | null): string;
+export declare function identifierRowValue(row: IdentifierBatchRow, request: IdentifierBatchRequest | null): string;
+/** Zeilen der Ergebnistabelle; wahlweise nur ungültige, fehlende und nicht prüfbare. */
+export declare function visibleIdentifierRows(answer: IdentifierBatchAnswer, onlyIssues: boolean): readonly IdentifierBatchRow[];
+export declare function identifierBatchSummary(answer: IdentifierBatchAnswer, t: IdentifierTranslate): string;
+/** Anzeigezeile der Stapelprüfung (Tabelle und CSV). */
+export interface IdentifierBatchLine {
+    key: number;
+    ref: string;
+    kind: string;
+    value: string;
+    status: string;
+    tone: IdentifierTone;
+    reason: string;
+    normalized: string;
+}
+export declare function identifierBatchLines(catalogue: IdentifierCatalogue, answer: IdentifierBatchAnswer, request: IdentifierBatchRequest | null, onlyIssues: boolean, t: IdentifierTranslate): IdentifierBatchLine[];
+/** CSV (Excel-DE) der Stapelprüfung mit denselben Spalten wie die Tabelle (alle Zeilen). */
+export declare function identifierBatchCsv(catalogue: IdentifierCatalogue, answer: IdentifierBatchAnswer, request: IdentifierBatchRequest | null, t: IdentifierTranslate): string;
+export type IdentifierColumn = 'value' | 'kind' | 'ref' | 'country';
+export interface IdentifierColumnField {
+    id: IdentifierColumn;
+    label: IdentifierMessageKey;
+    value: number | null;
+    /** Text der leeren Auswahl: „keine“ bei optionalen Spalten, „Bitte wählen“ bei der Spalte mit Kennungsart. */
+    placeholder: IdentifierMessageKey | null;
+}
+/** Spaltenauswahl der Stapelprüfung; die Spalte mit Kennungsart nur ohne feste Art. */
+export declare function identifierColumnFields(mapping: IdentifierBatchMapping): IdentifierColumnField[];

package/dist/identifiers/rest-port.d.ts

@@ -0,0 +1,4 @@
+import { RestOptions } from '@auditcore/common';
+import { IdentifiersPort } from './types';
+/** Port auf den REST-Vertrag `identifiers_ui/1` von `auditcore_identifiers.web` (Starlette oder FastAPI). */
+export declare function createIdentifiersRestPort(options: RestOptions): IdentifiersPort;

package/dist/identifiers/types.d.ts

@@ -0,0 +1,101 @@
+/** Typen des REST-Vertrags `identifiers_ui/1` (`docs/ui/identifiers-rest.md`, auditcore_identifiers.web). */
+export type IdentifierStatus = 'VALID' | 'INVALID' | 'MISSING';
+export interface IdentifierKindInfo {
+    id: string;
+    label: string;
+    description: string;
+    /** Land als Zusatzangabe sinnvoll (USt-IdNr. ohne Präfix). */
+    country: boolean;
+}
+export interface IdentifierProfileInfo {
+    id: string;
+    title: string;
+    rationale: string;
+    origin: string;
+    legacy: boolean;
+    /** Kennungsarten, die das Profil prüft. */
+    kinds: readonly string[];
+}
+export interface IdentifierCatalogue {
+    contract: string;
+    library: string;
+    recommended_profile: string;
+    kinds: readonly IdentifierKindInfo[];
+    profiles: readonly IdentifierProfileInfo[];
+    reasons: readonly {
+        id: string;
+        label: string;
+    }[];
+    detail_labels: Readonly<Record<string, string>>;
+    value_labels: Readonly<Record<string, string>>;
+    limits: {
+        max_items: number;
+        max_value_length: number;
+        max_body_bytes: number;
+    };
+}
+export type IdentifierDetailValue = string | number | boolean | null;
+export interface IdentifierResult {
+    kind: string;
+    kind_label: string;
+    status: IdentifierStatus;
+    raw: string | null;
+    normalized: string | null;
+    reason: string | null;
+    reason_label: string | null;
+    message: string;
+    country: string | null;
+    profile: string;
+    details: Readonly<Record<string, IdentifierDetailValue>>;
+}
+export interface IdentifierCheckRequest {
+    kind: string;
+    value: string | null;
+    profile: string;
+    country?: string | null;
+}
+export interface IdentifierCheckAnswer {
+    contract: string;
+    result: IdentifierResult;
+}
+export interface IdentifierBatchItem {
+    ref?: string;
+    kind: string;
+    value: string | null;
+    country?: string | null;
+}
+export interface IdentifierBatchRequest {
+    profile: string;
+    items: readonly IdentifierBatchItem[];
+}
+/** Zeile der Stapelprüfung: Ergebnisfelder oder `error` (Art unbekannt bzw. vom Profil nicht geprüft). */
+export type IdentifierBatchRow = {
+    index: number;
+    ref: string;
+} & (({
+    error: null;
+} & IdentifierResult) | {
+    error: {
+        code: string;
+        message: string;
+    };
+});
+export interface IdentifierBatchSummary {
+    total: number;
+    valid: number;
+    invalid: number;
+    missing: number;
+    not_checked: number;
+}
+export interface IdentifierBatchAnswer {
+    contract: string;
+    profile: string;
+    results: readonly IdentifierBatchRow[];
+    summary: IdentifierBatchSummary;
+}
+/** Schnittstelle zur Fachlogik; Standardumsetzung `createIdentifiersRestPort`. */
+export interface IdentifiersPort {
+    catalogue(): Promise<IdentifierCatalogue>;
+    check(request: IdentifierCheckRequest): Promise<IdentifierCheckAnswer>;
+    checkBatch(request: IdentifierBatchRequest): Promise<IdentifierBatchAnswer>;
+}

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Framework-freier Kern von `@auditcore/ui` (Vue) und `@auditcore/ui-react`:
+ * Texte, Datentypen der REST-Verträge, View-Modelle, Zustandsautomaten,
+ * Ports und Exporte. Kein Vue, kein React.
+ */
+export * from './i18n';
+export { baseMessages } from './messages';
+export { createStore, createRunner, createDelay, IDLE, type Store, type RequestState } from './store';
+export { downloadText, printHtml, deliverExport } from './download';
+export { createFocusTrap, focusableWithin, wrapTarget, type FocusTrap } from './focus';
+export * from './base';
+export { cellText, sortIcon, rowKeyOf, cellAlignClass } from './table';
+export * from './synopsis';
+export * from './dataprotection';
+export * from './geo';
+export * from './risk';
+export * from './screening';
+export * from './tabular';
+export * from './sampling';
+export * from './benford';
+export * from './extrapolation';
+export * from './documents';
+export * from './reporting';
+export * from './identifiers';
+export * from './extraction';
+export * from './kanban';
+export * from './dbkanban';
+export * from './batchchecks';
+export * from './samplesize';
+export * from './attributes';
+export * from './reporttemplates';
+export * from './runner';
+export * from './account';