@dialecte/core 0.6.3 → 0.7.0

package/dist/diagnostics/diagnostics.d.ts

@@ -0,0 +1,26 @@
+import { CreateDiagnosticParams, CreatedDiagnostic, Diagnostic, DiagnosticCatalogue, KnownDiagnosticCode } from './types';
+/**
+ * Build a diagnostic of a catalogue: `severity`, `source` and the default `message` come from the
+ * entry, so a producer only says what the diagnostic is about. The `meta` and `related` given keep
+ * their type on the way out, so a dialecte's typed diagnostic (`Diagnostic<'x'> & { meta: {…} }`) is
+ * what this returns when it is given that `meta`.
+ *
+ * @example
+ * createDiagnostic(SCL_IMPORT_DIAGNOSTICS, 'unresolved-reference', {
+ *   ref: { tagName: 'FunctionRef', id, attribute: 'function' },
+ *   meta: { pathValue, triedKeys },
+ * })
+ */
+export declare function createDiagnostic<const GenericCatalogue extends DiagnosticCatalogue, GenericCode extends keyof GenericCatalogue['codes'] & string, GenericParams extends CreateDiagnosticParams>(catalogue: GenericCatalogue, code: GenericCode, params: GenericParams): CreatedDiagnostic<GenericCode, GenericParams>;
+/**
+ * Whether a diagnostic is one the caller knows: an entry of one of the catalogues named, matched on
+ * the pair (`source`, `code`) - two dialectes may both have an `unresolved-reference`. Its `code` is
+ * then narrowed to those catalogues' codes, so a `switch` on it or a table read with it is checked.
+ *
+ * @example
+ * if (isKnownDiagnostic(diagnostic, { catalogues: [SCL_IMPORT_DIAGNOSTICS] })) sentences[diagnostic.code]
+ */
+export declare function isKnownDiagnostic<const GenericCatalogues extends readonly DiagnosticCatalogue[]>(diagnostic: Diagnostic, params: {
+    catalogues: GenericCatalogues;
+}): diagnostic is Diagnostic<KnownDiagnosticCode<GenericCatalogues>>;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../src/diagnostics/diagnostics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,sBAAsB,EACtB,iBAAiB,EACjB,UAAU,EACV,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,SAAS,CAAA;AAEhB;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,CAAC,gBAAgB,SAAS,mBAAmB,EAClD,WAAW,SAAS,MAAM,gBAAgB,CAAC,OAAO,CAAC,GAAG,MAAM,EAC5D,aAAa,SAAS,sBAAsB,EAE5C,SAAS,EAAE,gBAAgB,EAC3B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,aAAa,GACnB,iBAAiB,CAAC,WAAW,EAAE,aAAa,CAAC,CAiB/C;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,iBAAiB,SAAS,SAAS,mBAAmB,EAAE,EAC/F,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE;IAAE,UAAU,EAAE,iBAAiB,CAAA;CAAE,GACvC,UAAU,IAAI,UAAU,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,CAAC,CAKlE"}

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,3 @@
+export * from './diagnostics';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/diagnostics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/diagnostics/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,mBAAmB,SAAS,CAAA"}

package/dist/diagnostics/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The levels of the language-server protocol: `error` and `warning` say something is wrong,
+ * `information` reports what was done (a value rewritten on import), `hint` what could be better.
+ */
+export type DiagnosticSeverity = 'error' | 'warning' | 'information' | 'hint';
+/** What a diagnostic is about - the axis a reader filters by; a property of the catalogue entry, not of the diagnostic. */
+export type DiagnosticFamily = 'value' | 'attribute' | 'structure' | 'identity' | 'reference' | 'import';
+/** The record a diagnostic points at, and the attribute when it is about one. */
+export type DiagnosticRef = {
+    tagName: string;
+    id: string;
+    attribute?: string;
+};
+/**
+ * Something a producer - an import hook, a validation rule - says about one record of a document.
+ * The shape of the language-server protocol's `Diagnostic`, with `ref` where it has a text range
+ * and `meta` where it has `data`. Plain data: it crosses a worker boundary as is.
+ *
+ * Its identity is the pair (`source`, `code`): two dialectes may both have an `unresolved-reference`.
+ */
+export type Diagnostic<GenericCode extends string = string> = {
+    /** A code of the producer's catalogue. */
+    code: GenericCode;
+    severity: DiagnosticSeverity;
+    /** Who said it: `'core'` for definition rules, the dialecte's name for its hooks and domain rules. */
+    source: string;
+    /** Default wording; a consumer words it from `code` and `meta` and falls back to this. */
+    message: string;
+    ref: DiagnosticRef;
+    /** The other records it involves - an incoherent reference names two elements. */
+    related?: {
+        ref: DiagnosticRef;
+        message: string;
+    }[];
+    /** What it is about, as serializable data - the contract, with `code`; `message` is the convenience. */
+    meta?: Record<string, unknown>;
+};
+/** What a catalogue says of one code: the severity its diagnostics carry, their family, their default wording. */
+export type DiagnosticCatalogueEntry = {
+    severity: DiagnosticSeverity;
+    family: DiagnosticFamily;
+    message: string;
+};
+/**
+ * The diagnostics a producer may emit, by code, under one `source`. A dialecte writes one per
+ * concern (`SCL_IMPORT_DIAGNOSTICS`); a consumer narrows a diagnostic to its codes with
+ * `isKnownDiagnostic`.
+ */
+export type DiagnosticCatalogue = {
+    readonly source: string;
+    readonly codes: {
+        readonly [GenericCode: string]: DiagnosticCatalogueEntry;
+    };
+};
+/** What `createDiagnostic` is given beside the code: the record, and what the diagnostic is about. */
+export type CreateDiagnosticParams = {
+    ref: DiagnosticRef;
+    /** A wording for this occurrence; the entry's default otherwise. */
+    message?: string;
+    related?: Diagnostic['related'];
+    meta?: Record<string, unknown>;
+};
+/**
+ * What `createDiagnostic` returns: the diagnostic of that code, its `meta` and `related` typed as they
+ * were given - so a dialecte's `Diagnostic<'x'> & { meta: {…} }` is what comes out, with no cast.
+ */
+export type CreatedDiagnostic<GenericCode extends string, GenericParams extends CreateDiagnosticParams> = Omit<Diagnostic<GenericCode>, 'meta' | 'related'> & Omit<GenericParams, 'ref' | 'message'>;
+/** The codes of the catalogues named, as `isKnownDiagnostic` narrows them. */
+export type KnownDiagnosticCode<GenericCatalogues extends readonly DiagnosticCatalogue[]> = CodesOfCatalogue<GenericCatalogues[number]>;
+type CodesOfCatalogue<GenericCatalogue> = GenericCatalogue extends DiagnosticCatalogue ? keyof GenericCatalogue['codes'] & string : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/diagnostics/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/diagnostics/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,GAAG,aAAa,GAAG,MAAM,CAAA;AAE7E,2HAA2H;AAC3H,MAAM,MAAM,gBAAgB,GACzB,OAAO,GACP,WAAW,GACX,WAAW,GACX,UAAU,GACV,WAAW,GACX,QAAQ,CAAA;AAEX,iFAAiF;AACjF,MAAM,MAAM,aAAa,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,CAAC,WAAW,SAAS,MAAM,GAAG,MAAM,IAAI;IAC7D,0CAA0C;IAC1C,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,sGAAsG;IACtG,MAAM,EAAE,MAAM,CAAA;IACd,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,aAAa,CAAA;IAClB,kFAAkF;IAClF,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,aAAa,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACnD,wGAAwG;IACxG,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B,CAAA;AAED,kHAAkH;AAClH,MAAM,MAAM,wBAAwB,GAAG;IACtC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,MAAM,EAAE,gBAAgB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,wBAAwB,CAAA;KAAE,CAAA;CAC5E,CAAA;AAED,sGAAsG;AACtG,MAAM,MAAM,sBAAsB,GAAG;IACpC,GAAG,EAAE,aAAa,CAAA;IAClB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAA;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAC5B,WAAW,SAAS,MAAM,EAC1B,aAAa,SAAS,sBAAsB,IACzC,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,SAAS,CAAC,CAAA;AAE9F,8EAA8E;AAC9E,MAAM,MAAM,mBAAmB,CAAC,iBAAiB,SAAS,SAAS,mBAAmB,EAAE,IACvF,gBAAgB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAA;AAE5C,KAAK,gBAAgB,CAAC,gBAAgB,IAAI,gBAAgB,SAAS,mBAAmB,GACnF,MAAM,gBAAgB,CAAC,OAAO,CAAC,GAAG,MAAM,GACxC,KAAK,CAAA"}

package/dist/document/query/get/attribute/get-attribute.d.ts

@@ -5,10 +5,10 @@ import { AttributeDefaults } from '../../../../utils';
  * Fetch a single attribute for the given ref or record.
  *
  * Resolves the record (a record given in full is read as it is, through the staged
- * operations; a ref via staged → cache → store, see `resolveRecord`), then extracts the named
- * attribute. Pass `namespace` to scope by a namespace key (a local `name` is resolved
- * to the stored `prefix:local` key). `defaults` (default `'optional'`) controls the
- * fallback for an absent attribute: `'none'` → `''`; `'optional'` → `fixed` /
+ * operations; a ref via staged → cache → store, see `resolveRecord`), then reads the named
+ * attribute with {@link readAttribute}. Pass `namespace` to scope by a namespace key (a local
+ * `name` is resolved to the stored `prefix:local` key). `defaults` (default `'optional'`)
+ * controls the fallback for an absent attribute: `'none'` → `''`; `'optional'` → `fixed` /
  * non-empty `default` (else `''`); `'required'` → required/fixed materialized value.
  *
  * @example
@@ -24,9 +24,9 @@ export declare function getAttribute<GenericConfig extends AnyDialecteConfig, Ge
 }): Promise<GenericAttribute['value'] | ''>;
 /**
  * Fetch a single attribute for the given ref or record as a full object (name + value +
- * namespace). `defaults` (default `'optional'`) fills an absent schema attribute by
- * synthesizing its object; `'none'` returns `undefined` when the attribute is not
- * stored.
+ * namespace), read with {@link readAttribute}. `defaults` (default `'optional'`) fills an
+ * absent schema attribute by synthesizing its object; `'none'` returns `undefined` when the
+ * attribute is not stored.
  *
  * @example
  * getAttribute({ context, ref, name: 'name', fullObject: true }) // → FullAttributeObject | undefined

package/dist/document/query/get/attribute/get-attribute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-attribute.d.ts","sourceRoot":"","sources":["../../../../../src/document/query/get/attribute/get-attribute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CACjC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAmB1C;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC3C,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAyBxC"}
+{"version":3,"file":"get-attribute.d.ts","sourceRoot":"","sources":["../../../../../src/document/query/get/attribute/get-attribute.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AACnF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,YAAY,CACjC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAQ1C;AAED;;;;;;;;GAQG;AACH,wBAAsB,sBAAsB,CAC3C,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAQxC"}

package/dist/document/query/get/attribute/get-attributes.d.ts

@@ -3,7 +3,8 @@ import { AnyDialecteConfig, AttributesValueObjectOf, ElementsOf, FullAttributeOb
 import { AttributeDefaults } from '../../../../utils';
 /**
  * Fetch attributes for the given ref or record as a destructurable value object. A record given in full is read as it
- * is, through the staged operations, with no store round trip (see `resolveRecord`).
+ * is, through the staged operations, with no store round trip (see `resolveRecord`); the reading itself is
+ * {@link readAttributes}.
  *
  * Without `namespace`, every attribute under the name it is stored by (`aA`, `xsi:type`, `ext:cA`) - what a write takes
  * back. With a `namespace` key, only that namespace's attributes, with the prefix stripped from the keys
@@ -17,14 +18,15 @@ import { AttributeDefaults } from '../../../../utils';
  * getAttributes({ context, ref })                       // → { aA: '', bA: '', ... }
  * getAttributes({ context, ref, namespace: 'ext' })     // → { cA: '...' }
  */
-export declare function getAttributes<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, GenericAttribute extends FullAttributeObjectOf<GenericConfig, GenericElement>>(params: {
+export declare function getAttributes<GenericConfig extends AnyDialecteConfig, GenericElement extends ElementsOf<GenericConfig>, _GenericAttribute extends FullAttributeObjectOf<GenericConfig, GenericElement>>(params: {
     context: Context<GenericConfig>;
     ref: RefOrRecord<GenericConfig, GenericElement> | undefined;
     namespace?: string;
     defaults?: AttributeDefaults;
 }): Promise<AttributesValueObjectOf<GenericConfig, GenericElement>>;
 /**
- * Fetch all attributes of the given ref or record as a full array (name + value + namespace).
+ * Fetch all attributes of the given ref or record as a full array (name + value + namespace), read with
+ * {@link readAttributes}.
  *
  * `defaults` (default `'optional'`) fills absent schema attributes just like
  * {@link getAttributes}: `'none'` returns the faithful stored-only set;

package/dist/document/query/get/attribute/get-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-attributes.d.ts","sourceRoot":"","sources":["../../../../../src/document/query/get/attribute/get-attributes.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EACX,iBAAiB,EACjB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EAErB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;;;;;;;;GAeG;AAEH,wBAAsB,aAAa,CAClC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,uBAAuB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAqClE;AAmBD;;;;;;;;;;GAUG;AAEH,wBAAsB,uBAAuB,CAC5C,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CA6B9B"}
+{"version":3,"file":"get-attributes.d.ts","sourceRoot":"","sources":["../../../../../src/document/query/get/attribute/get-attributes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EACX,iBAAiB,EACjB,uBAAuB,EACvB,UAAU,EACV,qBAAqB,EACrB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;;;;;;;;;GAgBG;AAEH,wBAAsB,aAAa,CAClC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,iBAAiB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC7E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,uBAAuB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CASlE;AAED;;;;;;;;;;;GAWG;AAEH,wBAAsB,uBAAuB,CAC5C,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,UAAU,CAAC,aAAa,CAAC,EAChD,gBAAgB,SAAS,qBAAqB,CAAC,aAAa,EAAE,cAAc,CAAC,EAC5E,MAAM,EAAE;IACT,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAA;IAC/B,GAAG,EAAE,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,GAAG,SAAS,CAAA;IAC3D,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAW9B"}

package/dist/errors/codes.d.ts

@@ -127,6 +127,10 @@ export declare const ERROR_CATALOG: {
         readonly code: "D5003";
         readonly message: "Failed to parse XML";
     };
+    readonly IMPORT_FAILED: {
+        readonly code: "D5004";
+        readonly message: "Failed to import the file";
+    };
     readonly EXTENSION_METHOD_COLLISION: {
         readonly code: "D6001";
         readonly message: "Extension method name collision detected";

package/dist/errors/codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../src/errors/codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuKhB,CAAA"}
+{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../src/errors/codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2KhB,CAAA"}

package/dist/helpers/index.d.ts

@@ -6,4 +6,6 @@ export * from './assert-fixed';
 export * from './assert-xsi-type';
 export * from './merge-extensions';
 export * from './strip-attributes';
+export * from './read-attributes';
+export type * from './read-attributes.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/helpers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,mBAAmB,yBAAyB,CAAA"}

package/dist/helpers/read-attributes.d.ts

@@ -0,0 +1,56 @@
+import { ReadAttributesBaseParams } from './read-attributes.types';
+import { AnyAttribute } from '../types';
+/**
+ * Read one attribute of a record you hold, the way `query.getAttribute` reads it - same `namespace` scope, same
+ * `defaults` fill, same `''` for an absent attribute - with no query: synchronous, for an import pass or a pure
+ * composer. `query.getAttribute` itself delegates to it once it has the record.
+ *
+ * `fullObject: true` returns the attribute object, or `undefined` when there is none in that view: with
+ * `defaults: 'none'`, how to tell an absent attribute from one written empty.
+ *
+ * Reads the record as you hold it. Inside a transaction use `tx.getAttribute`, which sees the transaction's staged
+ * writes: a record held from before a write still reads its old values here.
+ *
+ * @example
+ * readAttribute({ record, dialecteConfig, name: 'aA' })                                      // → 'v' | ''
+ * readAttribute({ record, dialecteConfig, name: 'aA', defaults: 'none', fullObject: true }) // → undefined when absent
+ *
+ * @see {@link readAttributes}
+ */
+export declare function readAttribute(params: ReadAttributesBaseParams & {
+    name: string;
+    namespace?: string;
+    fullObject?: false;
+}): string;
+export declare function readAttribute(params: ReadAttributesBaseParams & {
+    name: string;
+    namespace?: string;
+    fullObject: true;
+}): AnyAttribute | undefined;
+/**
+ * Read the attributes of a record you hold, the way `query.getAttributes` reads them - each under the name it is
+ * stored by, or keyed by local name in a `namespace` scope, absent schema attributes filled per `defaults` - with no
+ * query: synchronous, for an import pass or a pure composer. `query.getAttributes`
+ * itself delegates to it once it has the record. Values are plain strings: for typed reads use the query.
+ *
+ * Namespace declarations are left out of the value object; `fullObject: true` returns the stored attributes as they
+ * are, a declaration a document carries included (stored by its prefix, in the xmlns namespace).
+ *
+ * Reads the record as you hold it. Inside a transaction use `tx.getAttributes`, which sees the transaction's staged
+ * writes: a record held from before a write still reads its old values here.
+ *
+ * @example
+ * readAttributes({ record, dialecteConfig })                        // → { aA: 'v', 'ext:cA': 'w' }
+ * readAttributes({ record, dialecteConfig, defaults: 'none' })      // → stored only
+ * readAttributes({ record, dialecteConfig, fullObject: true })      // → AnyAttribute[]
+ *
+ * @see {@link readAttribute}
+ */
+export declare function readAttributes(params: ReadAttributesBaseParams & {
+    namespace?: string;
+    fullObject?: false;
+}): Record<string, string>;
+export declare function readAttributes(params: ReadAttributesBaseParams & {
+    fullObject: true;
+}): AnyAttribute[];
+//# sourceMappingURL=read-attributes.d.ts.map

package/dist/helpers/read-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-attributes.d.ts","sourceRoot":"","sources":["../../src/helpers/read-attributes.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AACvE,OAAO,KAAK,EAAE,YAAY,EAA8C,MAAM,SAAS,CAAA;AAGvF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAA;CAAE,GACzF,MAAM,CAAA;AACT,wBAAgB,aAAa,CAC5B,MAAM,EAAE,wBAAwB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,IAAI,CAAA;CAAE,GACvF,YAAY,GAAG,SAAS,CAAA;AAyC3B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,wBAAwB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAA;CAAE,GAC3E,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACzB,wBAAgB,cAAc,CAC7B,MAAM,EAAE,wBAAwB,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,GACrD,YAAY,EAAE,CAAA"}

package/dist/helpers/read-attributes.types.d.ts

@@ -0,0 +1,10 @@
+import { AnyDialecteConfig, AnyRawRecord } from '../types';
+import { AttributeDefaults } from '../utils';
+/** What every attribute read takes: the record as held (raw, tracked or tree), the config its schema values come from. */
+export type ReadAttributesBaseParams = {
+    record: AnyRawRecord;
+    dialecteConfig: AnyDialecteConfig;
+    /** How an absent schema attribute is filled - as in `query.getAttribute(s)`. Default `'optional'`. */
+    defaults?: AttributeDefaults;
+};
+//# sourceMappingURL=read-attributes.types.d.ts.map

package/dist/helpers/read-attributes.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-attributes.types.d.ts","sourceRoot":"","sources":["../../src/helpers/read-attributes.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,0HAA0H;AAC1H,MAAM,MAAM,wBAAwB,GAAG;IACtC,MAAM,EAAE,YAAY,CAAA;IACpB,cAAc,EAAE,iBAAiB,CAAA;IACjC,sGAAsG;IACtG,QAAQ,CAAC,EAAE,iBAAiB,CAAA;CAC5B,CAAA"}