@streamline-pulse/formkrafter-core 0.28.1 → 0.30.0

package/dist/services/document_reader_service.d.ts

@@ -0,0 +1,57 @@
+import type { FileLike } from "./file_upload_service.js";
+/**
+ * What a document reader returns for a scanned or uploaded document: the
+ * text it could read, the fields it was asked for, and some metadata. The
+ * reader itself (OCR, layout analysis, a language model…) lives on the host:
+ * FormKrafter only sends the file and keeps the answer.
+ */
+export interface DocumentReading {
+    /** Plain text (or Markdown) read from the document. */
+    text?: string;
+    /** The fields that were requested, by key; `null` when not found. */
+    fields?: Record<string, unknown>;
+    pages?: number;
+    /** Free label of the engine that produced the reading. */
+    engine?: string;
+    /** Reading confidence in [0, 1] when the engine provides one. */
+    confidence?: number;
+    warnings?: string[];
+}
+export interface DocumentReadOptions {
+    url?: string;
+    headers?: Record<string, string>;
+    /** Field keys the reader should extract (see `parseDocumentFields`). */
+    fields?: {
+        key: string;
+        label?: string;
+    }[];
+    /** Language hint for OCR, e.g. `fr`. */
+    language?: string;
+    /**
+     * The form context (`_`-prefixed keys such as `_processVersionId`). The
+     * default reader does not send it; a host reader may use it to scope the
+     * reading (organisation, process…).
+     */
+    context?: Record<string, unknown>;
+}
+export interface DocumentReaderService {
+    read(file: FileLike, options?: DocumentReadOptions): Promise<DocumentReading>;
+}
+export interface FetchDocumentReaderDefaults {
+    url?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    fieldName?: string;
+    fetch?: typeof fetch;
+}
+/** Normalises whatever a reader answered into a `DocumentReading`. */
+export declare function readDocumentReading(payload: unknown): DocumentReading;
+/**
+ * Default reader: POSTs the file as multipart (`file`, plus `fields` as a
+ * comma-separated list and `language`) to the URL and reads the JSON answer.
+ */
+export declare class FetchDocumentReaderService implements DocumentReaderService {
+    private readonly defaults;
+    constructor(defaults?: FetchDocumentReaderDefaults);
+    read(file: FileLike, options?: DocumentReadOptions): Promise<DocumentReading>;
+}

package/dist/services/index.d.ts

@@ -3,12 +3,14 @@ import { type DataSourceService } from "./data_source_service.js";
 import { type FileUploadService } from "./file_upload_service.js";
 import { type SpecSourceService } from "./spec_source_service.js";
 import { type OptionSourceService } from "./option_source_service.js";
+import { type DocumentReaderService } from "./document_reader_service.js";
 export interface Services {
     jsRunnerService: JsRunnerService;
     dataSourceService: DataSourceService;
     fileUploadService: FileUploadService;
     specSourceService: SpecSourceService;
     optionSourceService: OptionSourceService;
+    documentReaderService: DocumentReaderService;
 }
 declare const services: Services;
 export { services };

package/dist/utils/documents.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Document bricks: the fields a reader should look for and the form keys they
+ * fill, both written one per line in the brick configuration.
+ */
+export interface DocumentField {
+    key: string;
+    label?: string;
+}
+/** `key|Label` per line (or `key` alone); blank lines and `#` comments ignored. */
+export declare function parseDocumentFields(source: unknown): DocumentField[];
+/** `field=formKey` per line: which form key each read field fills. */
+export declare function parseDocumentFills(source: unknown): Record<string, string>;
+/** The form patch a reading produces: only the mapped fields with a value. */
+export declare function documentFillPatch(fields: Record<string, unknown> | undefined, fills: Record<string, string>): Record<string, unknown>;

package/dist/utils/registries.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Public registries: vehicle plates and company registration numbers, each
+ * checked against a named format (per country, or a generic one).
+ */
+interface Format {
+    id: string;
+    label: string;
+    /** Tested against the compacted, upper-cased value. */
+    test: (value: string) => boolean;
+    /** Display form of a valid value (compacted input). */
+    format?: (value: string) => string;
+}
+export declare const PLATE_FORMATS: Format[];
+export declare const REGISTRY_FORMATS: Format[];
+/** Compact form kept in the data for plates (letters and digits only, upper case). */
+export declare const compactPlate: (value: string) => string;
+export declare function checkPlate(format: string, value: string): boolean;
+export declare function formatPlate(format: string, value: string): string;
+export declare function checkCompanyRegistry(format: string, value: string): boolean;
+export declare function formatCompanyRegistry(format: string, value: string): string;
+export {};

package/dist/utils/units.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Measures: a number with a unit, kept with its value in the family's base
+ * unit so sums and averages stay meaningful whatever unit each answer used.
+ */
+export type MeasureFamily = "length" | "area" | "mass" | "volume" | "duration";
+export interface MeasureUnit {
+    id: string;
+    /** Symbol shown to the user. */
+    symbol: string;
+    /** Multiply a value in this unit by `factor` to get the family's base unit. */
+    factor: number;
+}
+export interface MeasureValue {
+    value: number;
+    unit: string;
+    /** `value` converted to the family's base unit. */
+    base: number;
+}
+export declare const MEASURE_FAMILIES: Record<MeasureFamily, {
+    base: string;
+    units: MeasureUnit[];
+}>;
+export declare const measureFamilyOf: (value: unknown) => MeasureFamily;
+/** The units of a family, restricted to `allowed` (comma-separated ids) when given. */
+export declare function measureUnits(family: MeasureFamily, allowed?: unknown): MeasureUnit[];
+export declare function unitOf(family: MeasureFamily, id: string): MeasureUnit | undefined;
+/** Converts between two units of the same family; `undefined` when a unit is unknown. */
+export declare function convertMeasure(family: MeasureFamily, value: number, from: string, to: string): number | undefined;
+/** Builds the stored value: the number, its unit and the base-unit equivalent. */
+export declare function measureValue(family: MeasureFamily, value: number, unit: string): MeasureValue | undefined;
+/** Human form, e.g. `2,5 ha`. */
+export declare function formatMeasure(family: MeasureFamily, value: MeasureValue | undefined, locale?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamline-pulse/formkrafter-core",
-  "version": "0.28.1",
+  "version": "0.30.0",
   "description": "Framework-agnostic core for FormKrafter: form specs, RFC 6902 ops with undo/redo, Ajv validation, sandboxed rules engine and injectable services",
   "license": "MIT",
   "type": "module",