@dialecte/core 0.6.4 → 0.8.0

package/dist/test/assert-xml/assert-xml.d.ts

@@ -1,46 +1,35 @@
-import { NsResolver } from './types';
+import { XmlNamespaces } from '../xml';
+import { XmlAssertions, XmlQueriesWithNamespacesParams, XmlQueryChecks } from './assert-xml.types';
 import { Namespace } from '../../types';
 /**
- * Creates a pair of assertion functions pre-configured with a namespace resolver
- * derived from a prefix → URI map. Intended to be instantiated once per dialecte
- * (e.g. in scl test) and re-exported alongside createTestProject.
+ * The query assertions of a dialecte: XPath prefixes are its config's namespace keys, mapped to their URIs
+ * once here. Made once per dialecte (e.g. in scl's test entry) and offered beside `createTestProject`.
+ *
+ * @intent make XPath assertions bound to a dialecte's namespaces, assert exported XML in tests
  */
 export declare function createXmlAssertions(params: {
     namespaces: Record<string, Namespace>;
-}): {
-    assertExpectedElementQueries(params: {
-        xmlDocument: XMLDocument;
-        queries: string[];
-    }): void;
-    assertUnexpectedElementQueries(params: {
-        xmlDocument: XMLDocument;
-        queries: string[];
-    }): void;
-};
+}): XmlAssertions;
 /**
- * Assert that each XPath query matches at least one element in the document.
- * When a query fails, the error message shows which step failed
- * and the XML of the last successful match for debugging.
+ * Asserts that each XPath query selects at least one node of the XML text, parsed once for all of them.
+ * A failure names the steps that matched, the step that failed, where the last match sits, what the failing
+ * step finds there without its predicates, and the XML around it.
+ *
+ * @intent assert that XML holds the elements XPath queries select, check that an export holds an element
  */
-export declare function assertExpectedElementQueries(params: {
-    xmlDocument: XMLDocument;
-    queries: string[];
-    nsResolver?: NsResolver;
-}): void;
+export declare function assertExpectedElementQueries(params: XmlQueriesWithNamespacesParams): void;
 /**
- * Assert that each XPath query does NOT match any element in the document.
+ * Asserts that no XPath query selects a node of the XML text, parsed once for all of them.
  *
- * Progressive evaluation: all steps except the last one MUST exist
- * (to confirm the assertion is meaningful), and only the final step
- * must be absent. This prevents false positives where the query passes
- * because an ancestor doesn't exist (test setup bug) rather than the
- * target element being properly absent.
+ * Every step but the last must still select a node: an absence is only meaningful when the ancestors
+ * exist, so a missing ancestor (a fixture bug) fails the assertion instead of passing it for the wrong
+ * reason.
  *
- * For single-step queries, the full XPath is simply asserted as absent.
+ * @intent assert that XML does not hold an element, check that an element was removed from an export
  */
-export declare function assertUnexpectedElementQueries(params: {
-    xmlDocument: XMLDocument;
-    queries: string[];
-    nsResolver?: NsResolver;
-}): void;
+export declare function assertUnexpectedElementQueries(params: XmlQueriesWithNamespacesParams): void;
+/** The expected then the unexpected queries of one text, on one parse of it. */
+export declare function assertXmlQueries(params: XmlQueryChecks): void;
+/** XPath prefix to namespace URI, from a config's namespaces. */
+export declare function toXmlNamespaces(namespaces: Record<string, Namespace>): XmlNamespaces;
 //# sourceMappingURL=assert-xml.d.ts.map

package/dist/test/assert-xml/assert-xml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert-xml.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/assert-xml.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAAE;yCAK9C;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE;2CAG7C;QAAE,WAAW,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE;EAIvF;AACD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE;IACpD,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,UAAU,CAAA;CACvB,QAKA;AAWD;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACtD,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,CAAC,EAAE,UAAU,CAAA;CACvB,QAKA"}
+{"version":3,"file":"assert-xml.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/assert-xml.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAe,aAAa,EAAW,MAAM,QAAQ,CAAA;AACjE,OAAO,KAAK,EAEX,aAAa,EAEb,8BAA8B,EAC9B,cAAc,EACd,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAC3C,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CACrC,GAAG,aAAa,CAUhB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,8BAA8B,GAAG,IAAI,CAGzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,8BAA8B,GAAG,IAAI,CAG3F;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAM7D;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,aAAa,CAIpF"}

package/dist/test/assert-xml/assert-xml.types.d.ts

@@ -0,0 +1,48 @@
+import { XmlNamespaces, XmlNode } from '../xml';
+import { Namespace } from '../../types';
+/** XPath queries on XML text; prefixes are the dialecte config's namespace keys. */
+export type XmlQueriesParams = {
+    xml: string;
+    queries: string[];
+};
+/** XPath queries on XML text, with the namespaces their prefixes stand for: without them no prefix resolves. */
+export type XmlQueriesWithNamespacesParams = XmlQueriesParams & {
+    namespaces?: Record<string, Namespace>;
+};
+/** The expected then the unexpected queries of one XML text, on one parse of it. */
+export type XmlQueryChecks = {
+    xml: string;
+    namespaces: XmlNamespaces;
+    expectedQueries?: string[];
+    unexpectedQueries?: string[];
+};
+/** A query's progressive steps run in order until one selects nothing. */
+export type QueryTrace = {
+    steps: string[];
+    /** How many steps selected a node before the first that selected none. */
+    matchedSteps: number;
+    /** The first node the last matching step selected. */
+    lastMatch: XmlNode | undefined;
+};
+/** A location step of an XPath, read for a failure message. */
+export type XpathStepReading = {
+    /** The step as written, its predicates left out (`//default:A[@aA="1"]` → `//default:A`). */
+    withoutPredicates: string;
+    /** The separator before the step: `/`, `//`, or nothing for a relative first step. */
+    separator: string;
+    /** The axis written before the name test (`following-sibling`); undefined for the abbreviated ones. */
+    axis: string | undefined;
+    /** The name test as a qualified name; undefined when the step tests no name (`*`, `node()`, `..`). */
+    name: {
+        prefix: string | undefined;
+        localName: string;
+    } | undefined;
+    /** The attributes the predicates name (`@aA`, `@ext:aAA_3`), as written. */
+    predicateAttributes: string[];
+};
+/** The query assertions a dialecte offers: what `createXmlAssertions` makes (named, so a consumer can type with it). */
+export type XmlAssertions = {
+    assertExpectedElementQueries(params: XmlQueriesParams): void;
+    assertUnexpectedElementQueries(params: XmlQueriesParams): void;
+};
+//# sourceMappingURL=assert-xml.types.d.ts.map

package/dist/test/assert-xml/assert-xml.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-xml.types.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/assert-xml.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,oFAAoF;AACpF,MAAM,MAAM,gBAAgB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAEjE,gHAAgH;AAChH,MAAM,MAAM,8BAA8B,GAAG,gBAAgB,GAAG;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CACtC,CAAA;AAED,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,aAAa,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,0EAA0E;AAC1E,MAAM,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;IACpB,sDAAsD;IACtD,SAAS,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,+DAA+D;AAC/D,MAAM,MAAM,gBAAgB,GAAG;IAC9B,6FAA6F;IAC7F,iBAAiB,EAAE,MAAM,CAAA;IACzB,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAA;IACjB,uGAAuG;IACvG,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;IACxB,sGAAsG;IACtG,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;IACnE,4EAA4E;IAC5E,mBAAmB,EAAE,MAAM,EAAE,CAAA;CAC7B,CAAA;AAED,wHAAwH;AACxH,MAAM,MAAM,aAAa,GAAG;IAC3B,4BAA4B,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC5D,8BAA8B,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAAA;CAC9D,CAAA"}

package/dist/test/assert-xml/describe-nearby.d.ts

@@ -0,0 +1,16 @@
+import { XmlDocument, XmlNamespaces, XmlNode } from '../xml';
+/**
+ * What the failing step selects once its predicates are left out, under every node the matched prefix selects
+ * (or from the document when nothing matched): up to ten candidates, each with the attributes the predicates name
+ * and its line. When no node has the step's name there, `none: <tag> has no <name> <axis>`, and the same local
+ * name in another namespace is named with the prefix that stands for it. Undefined when the step cannot be read so,
+ * and for a union: its branches are not one step, so leaving out predicates would only repeat the query.
+ */
+export declare function describeNearby(params: {
+    document: XmlDocument;
+    namespaces: XmlNamespaces;
+    matchedPrefix: string | undefined;
+    firstMatch: XmlNode | undefined;
+    failedStep: string;
+}): string | undefined;
+//# sourceMappingURL=describe-nearby.d.ts.map

package/dist/test/assert-xml/describe-nearby.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-nearby.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/describe-nearby.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAmB,MAAM,QAAQ,CAAA;AAGlF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,QAAQ,EAAE,WAAW,CAAA;IACrB,UAAU,EAAE,aAAa,CAAA;IACzB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,UAAU,EAAE,OAAO,GAAG,SAAS,CAAA;IAC/B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,MAAM,GAAG,SAAS,CAarB"}

package/dist/test/assert-xml/describe-node-place.d.ts

@@ -0,0 +1,15 @@
+import { XmlAttribute, XmlElement, XmlNode } from '../xml';
+/**
+ * Where a node sits: its positional path from the root (`/Root[1]/A[2]/ext:B[1]`, `.../text()[1]`, each step
+ * counted among the siblings of the same name and namespace, or of the same kind) and its line, as a message
+ * says it (`line 12`; `line ≥ 65535` past the last line the engine keeps).
+ */
+export declare function describeNodePlace(node: XmlNode): {
+    path: string;
+    line: string;
+};
+/** The element's name as the document writes it: `prefix:name`, or `name` in the default namespace. */
+export declare function qualifiedNameOf(node: XmlElement | XmlAttribute): string;
+/** A line as a message says it: the engine keeps a line up to 65535, a later one reads as that bound. */
+export declare function formatLine(line: number): string;
+//# sourceMappingURL=describe-node-place.d.ts.map

package/dist/test/assert-xml/describe-node-place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-node-place.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/describe-node-place.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAwB,UAAU,EAAW,MAAM,QAAQ,CAAA;AAGhF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAErC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAO/E;AAED,uGAAuG;AACvG,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,MAAM,CAEvE;AAED,yGAAyG;AACzG,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/test/assert-xml/index.d.ts

@@ -1,3 +1,3 @@
 export { assertExpectedElementQueries, assertUnexpectedElementQueries, createXmlAssertions, } from './assert-xml';
-export { splitXpathIntoSteps } from './xpath-parser';
+export type { XmlAssertions, XmlQueriesParams, XmlQueriesWithNamespacesParams, } from './assert-xml.types';
 //# sourceMappingURL=index.d.ts.map

package/dist/test/assert-xml/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,4BAA4B,EAC5B,8BAA8B,EAC9B,mBAAmB,GACnB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,4BAA4B,EAC5B,8BAA8B,EAC9B,mBAAmB,GACnB,MAAM,cAAc,CAAA;AACrB,YAAY,EACX,aAAa,EACb,gBAAgB,EAChB,8BAA8B,GAC9B,MAAM,oBAAoB,CAAA"}

package/dist/test/assert-xml/query-failure-message.d.ts

@@ -0,0 +1,24 @@
+import { XmlDocument, XmlNamespaces, XmlNode } from '../xml';
+import { QueryTrace } from './assert-xml.types';
+/**
+ * A query that selects nothing, as labelled lines: the query, the steps that matched, the step that failed,
+ * where the last match sits, what the failing step finds there without its predicates, and the XML around it.
+ */
+export declare function describeMissingElement(params: {
+    header: string;
+    query: string;
+    trace: QueryTrace;
+    document: XmlDocument;
+    namespaces: XmlNamespaces;
+}): string;
+/** A query of the unexpected list that selects a node: where it sits, and the node. */
+export declare function describeUnexpectedElement(params: {
+    query: string;
+    node: XmlNode;
+}): string;
+/** A query the engine refused: the query and why. */
+export declare function describeRefusedQuery(params: {
+    query: string;
+    reason: string;
+}): string;
+//# sourceMappingURL=query-failure-message.d.ts.map

package/dist/test/assert-xml/query-failure-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-failure-message.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/query-failure-message.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,UAAU,CAAA;IACjB,QAAQ,EAAE,WAAW,CAAA;IACrB,UAAU,EAAE,aAAa,CAAA;CACzB,GAAG,MAAM,CA2BT;AAED,uFAAuF;AACvF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,CAQ1F;AAED,qDAAqD;AACrD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAOtF"}

package/dist/test/assert-xml/read-xpath-step.d.ts

@@ -0,0 +1,8 @@
+import { XpathStepReading } from './assert-xml.types';
+/**
+ * Reads one location step of an XPath as `splitXpathIntoSteps` cuts it (`/default:A[@aA="1"]`,
+ * `//ext:B`, `/following-sibling::default:C[2]`): the step without its predicates, its axis, its name
+ * test and the attributes its predicates name. Quotes and nested brackets are respected.
+ */
+export declare function readXpathStep(step: string): XpathStepReading;
+//# sourceMappingURL=read-xpath-step.d.ts.map

package/dist/test/assert-xml/read-xpath-step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-xpath-step.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/read-xpath-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAa5D"}

package/dist/test/assert-xml/xpath-parser.d.ts

@@ -11,7 +11,8 @@
  * - `[...]` predicates (including nested `[A[B]]` and paths inside `[@x="a/b"]`)
  * - `(...)` grouping
  * - Quoted strings with `/` inside (`@path="a/b/c"`)
- * - `|` union operator (treated as separate branches, not step boundaries)
+ * - `|` union operator: a top-level union is not split (one step, the whole query); one inside `[]` or `()` is
+ *   part of its step
  * - Leading `/` or `//` (absolute paths)
  * - Axis selectors like `following-sibling::` (not confused with `/`)
  */

package/dist/test/assert-xml/xpath-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xpath-parser.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/xpath-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAa3D"}
+{"version":3,"file":"xpath-parser.d.ts","sourceRoot":"","sources":["../../../src/test/assert-xml/xpath-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAa3D"}

package/dist/test/config.d.ts

@@ -1918,6 +1918,7 @@ export declare const TEST_DIALECTE_CONFIG: {
             };
             readonly children: {
                 readonly sequence: readonly ["CCC_1", "CCC_2", "CCC_3"];
+                readonly any: true;
                 readonly details: {};
             };
             readonly contentModel: {
@@ -1925,6 +1926,10 @@ export declare const TEST_DIALECTE_CONFIG: {
                 readonly minOccurs: 1;
                 readonly maxOccurs: 1;
                 readonly particles: readonly [{
+                    readonly kind: "any";
+                    readonly notNamespace: readonly ["", "http://dialecte.dev/XML/DEFAULT"];
+                    readonly processContents: "lax";
+                }, {
                     readonly kind: "element";
                     readonly name: "CCC_1";
                     readonly minOccurs: 1;

package/dist/test/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/test/config.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,SAAS;;CAEO,CAAA;AAG7B,eAAO,MAAM,eAAe;;;;;;;IAO3B,uEAAuE;;;;;;;CAQrC,CAAA;AAEnC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAVhC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBlC,CAAA;AAEtC,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/test/config.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,SAAS;;CAEO,CAAA;AAG7B,eAAO,MAAM,eAAe;;;;;;;IAO3B,uEAAuE;;;;;;;CAQrC,CAAA;AAEnC,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAVhC,uEAAuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBlC,CAAA;AAEtC,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAA"}

package/dist/test/constant.d.ts

@@ -19,4 +19,6 @@ export declare const DIALECTE_TEST_NAMESPACES: {
 export declare const XMLNS_DEFAULT_NAMESPACE: string;
 export declare const XMLNS_DEV_NAMESPACE: string;
 export declare const XMLNS_EXT_NAMESPACE: string;
+/** The config key of core's own test dialecte, and of a config given to the test helpers on its own. */
+export declare const TEST_CONFIG_KEY = "default";
 //# sourceMappingURL=constant.d.ts.map

package/dist/test/constant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/test/constant.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;CAUpC,CAAA;AAED,eAAO,MAAM,uBAAuB,QAAoD,CAAA;AACxF,eAAO,MAAM,mBAAmB,QAAuF,CAAA;AACvH,eAAO,MAAM,mBAAmB,QAAuF,CAAA"}
+{"version":3,"file":"constant.d.ts","sourceRoot":"","sources":["../../src/test/constant.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;CAUpC,CAAA;AAED,eAAO,MAAM,uBAAuB,QAAoD,CAAA;AACxF,eAAO,MAAM,mBAAmB,QAAuF,CAAA;AACvH,eAAO,MAAM,mBAAmB,QAAuF,CAAA;AAEvH,wGAAwG;AACxG,eAAO,MAAM,eAAe,YAAY,CAAA"}

package/dist/test/create-test-dialecte.d.ts

@@ -1,42 +1,37 @@
-import { TEST_DIALECTE_CONFIG } from './config';
-import { Project } from '../project';
-import { Document, Context, ExtensionModules, MergedExtensions } from '../document';
-import { AnyDialecteConfig, DialecteHooks } from '../types';
-type TestDialecteConfig = typeof TEST_DIALECTE_CONFIG;
-export type TestDocument<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
-    documentId: string;
-    document: Document<GenericConfig, MergedExtensions<GenericModules>>;
-};
-export type TestProjectResult<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
-    project: Project<GenericConfig, GenericModules>;
-    source: TestDocument<GenericConfig, GenericModules>;
-    target?: TestDocument<GenericConfig, GenericModules>;
-};
+import { TestDialecteConfig } from './config';
+import { DeclaredTestProjectParams, LegacyTestProjectParams, TestContextParams, TestProjectResult } from './create-test-dialecte.types';
+import { Context, ExtensionModules } from '../document';
+import { AnyDialecteConfig } from '../types';
 /**
- * Spin up a Project with source (and optionally target) file imported.
- * Returns project + pre-opened documents. Caller owns lifecycle via project.destroy().
+ * Spin up a Project of the declared dialecte - every config, the default key, its extensions and
+ * its own hooks instance; core's own test dialecte when none is given - with the source (and
+ * optionally the target) imported under the default config. Returns project + pre-opened
+ * documents. Opened inside a running test, the project is destroyed when the test ends (after its other
+ * `onTestFinished` hooks); opened outside one (`beforeAll`), the caller destroys it.
+ *
+ * @intent open a project in a test with a fixture imported, get documents to test against
  */
-export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: {
-    sourceXml: string;
-    targetXml?: string;
-    dialecteConfig?: GenericConfig;
-    extensions?: {
-        base?: ExtensionModules;
-        custom?: ExtensionModules;
-    };
-    hooks?: DialecteHooks<GenericConfig>;
-    dev?: {
-        perf?: boolean;
-    };
-}): Promise<TestProjectResult<GenericConfig, GenericModules>>;
+export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string>(params: DeclaredTestProjectParams<GenericConfig, GenericModules, GenericConfigKey>): Promise<TestProjectResult<GenericConfig, GenericModules>>;
 /**
- * Create a Context directly from a databaseName for testing FP query functions.
- * Opens the store to discover existing tables.
+ * Spin up a Project from a config, extensions and hooks given one by one, with the source (and
+ * optionally the target) imported under the key `default`.
+ * @deprecated Declare the dialecte with `defineDialecte` and pass it as `dialecte`.
  */
-export declare function createTestContext<GenericConfig extends AnyDialecteConfig>(params: {
-    databaseName: string;
-    dialecteConfig: GenericConfig;
-    documentId: string;
-}): Promise<Context<GenericConfig>>;
-export {};
+export declare function createTestProject<GenericConfig extends AnyDialecteConfig = TestDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>>(params: LegacyTestProjectParams<GenericConfig>): Promise<TestProjectResult<GenericConfig, GenericModules>>;
+/**
+ * Create a Context directly for testing FP query functions: on `store` when given, else on the store
+ * of the project named `databaseName` - of the kind `storage` names, else the test helpers' default
+ * (`useTestStorage`), else the local store - opened to discover its tables. Opened by name, it is a
+ * connection of its own: the project cannot be destroyed while it is open - `closeTestContexts()` first.
+ *
+ * @internal test context of core's own context-level query tests
+ */
+export declare function createTestContext<GenericConfig extends AnyDialecteConfig>(params: TestContextParams<GenericConfig>): Promise<Context<GenericConfig>>;
+/**
+ * Close every store `createTestContext` opened by name, so the projects they read can be destroyed: settled once
+ * they count no more.
+ *
+ * @internal cleanup of `createTestContext`
+ */
+export declare function closeTestContexts(): Promise<void>;
 //# sourceMappingURL=create-test-dialecte.d.ts.map

package/dist/test/create-test-dialecte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAA;AAK/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAE/D,KAAK,kBAAkB,GAAG,OAAO,oBAAoB,CAAA;AAErD,MAAM,MAAM,YAAY,CACvB,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,QAAQ,CAAC,aAAa,EAAE,gBAAgB,CAAC,cAAc,CAAC,CAAC,CAAA;CACnE,CAAA;AAED,MAAM,MAAM,iBAAiB,CAC5B,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH,OAAO,EAAE,OAAO,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;IAC/C,MAAM,EAAE,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;IACnD,MAAM,CAAC,EAAE,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;CACpD,CAAA;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC5D,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC7D,MAAM,EAAE;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;IAC9B,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,gBAAgB,CAAA;KAAE,CAAA;IACnE,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAA;IACpC,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CACxB,GAAG,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAmD5D;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,aAAa,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;CAClB,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAqBlC"}
+{"version":3,"file":"create-test-dialecte.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAClD,OAAO,KAAK,EACX,yBAAyB,EACzB,uBAAuB,EACvB,iBAAiB,EACjB,iBAAiB,EACjB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAG3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC5D,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC9D,gBAAgB,SAAS,MAAM,GAAG,MAAM,EAExC,MAAM,EAAE,yBAAyB,CAAC,aAAa,EAAE,cAAc,EAAE,gBAAgB,CAAC,GAChF,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAAA;AAC5D;;;;GAIG;AACH,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,iBAAiB,GAAG,kBAAkB,EAC5D,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAE9D,MAAM,EAAE,uBAAuB,CAAC,aAAa,CAAC,GAC5C,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAAA;AAoB5D;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,aAAa,SAAS,iBAAiB,EAC9E,MAAM,EAAE,iBAAiB,CAAC,aAAa,CAAC,GACtC,OAAO,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAoBjC;AAmCD;;;;;GAKG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAIvD"}

package/dist/test/create-test-dialecte.types.d.ts

@@ -0,0 +1,99 @@
+import { DialecteDeclaration } from '../dialecte';
+import { Document, ExtensionModules, MergedExtensions } from '../document';
+import { Project, StorageParam } from '../project';
+import { Store } from '../store';
+import { AnyDialecteConfig, DialecteHooks } from '../types';
+export type TestDocument<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
+    documentId: string;
+    document: Document<GenericConfig, MergedExtensions<GenericModules>>;
+};
+export type TestProjectResult<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
+    project: Project<GenericConfig, GenericModules>;
+    source: TestDocument<GenericConfig, GenericModules>;
+    target?: TestDocument<GenericConfig, GenericModules>;
+};
+/** The dialecte as declared: every config, the default key, its extensions, fresh hooks per project. */
+export type DeclaredTestDialecteParams<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string> = {
+    dialecte: DialecteDeclaration<GenericConfig, GenericModules, GenericConfigKey>;
+};
+/** The dialecte in parts: one config under the key `default`, extensions, one hooks instance. */
+export type LegacyTestDialecteParams<GenericConfig extends AnyDialecteConfig> = {
+    dialecte?: never;
+    /**
+     * Defaults to core's own test config.
+     * @deprecated Declare the dialecte with `defineDialecte` and pass it as `dialecte`.
+     */
+    dialecteConfig?: GenericConfig;
+    /** @deprecated The declaration's `extensions`. */
+    extensions?: {
+        base?: ExtensionModules;
+        custom?: ExtensionModules;
+    };
+    /**
+     * Shared by every project built from these parts.
+     * @deprecated The declaration's `createHooks`.
+     */
+    hooks?: DialecteHooks<GenericConfig>;
+};
+/** `createTestProject` on a declaration; without one, core's own test dialecte. */
+export type DeclaredTestProjectParams<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string> = TestProjectOptions & Partial<DeclaredTestDialecteParams<GenericConfig, GenericModules, GenericConfigKey>>;
+/** `createTestProject` on a dialecte given in parts. */
+export type LegacyTestProjectParams<GenericConfig extends AnyDialecteConfig> = TestProjectOptions & LegacyTestDialecteParams<GenericConfig>;
+/** `createTestRunner` on a declaration. */
+export type DeclaredTestRunnerParams<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string> = DeclaredTestDialecteParams<GenericConfig, GenericModules, GenericConfigKey> & {
+    /**
+     * The store the test projects run on: the test helpers' default when absent (`useTestStorage`, else the local
+     * store). `sqlite`: the SQLite engine in this process.
+     */
+    storage?: StorageParam;
+};
+/** `createTestRunner` on a dialecte given in parts. */
+export type LegacyTestRunnerParams<GenericConfig extends AnyDialecteConfig> = LegacyTestDialecteParams<GenericConfig> & {
+    dialecteConfig: GenericConfig;
+    /**
+     * The store the test projects run on: the test helpers' default when absent (`useTestStorage`, else the local
+     * store). `sqlite`: the SQLite engine in this process.
+     */
+    storage?: StorageParam;
+};
+/** `createTestContext`: the store to read, or the project to open by its name and dialecte. */
+export type TestContextParams<GenericConfig extends AnyDialecteConfig> = {
+    dialecteConfig: GenericConfig;
+    documentId: string;
+} & ({
+    store: Store;
+    databaseName?: undefined;
+    dialecteId?: undefined;
+    storage?: undefined;
+} | {
+    databaseName: string;
+    /**
+     * The dialecte of the project named, as the project says it (`project.dialecteId`): with the name, which
+     * project the in-memory and SQLite stores hold. `undefined` for a project made with no dialecte (refused
+     * `ASSERTION_FAILED` on `sqlite`).
+     */
+    dialecteId: string | undefined;
+    /**
+     * The store of the project named; the test helpers' default when absent (`useTestStorage`, else the local
+     * store). `sqlite`: the SQLite engine in this process. A context reads: an import through it runs with no
+     * dialecte hooks.
+     */
+    storage?: StorageParam;
+    store?: undefined;
+});
+export type TestProjectOptions = {
+    sourceXml: string;
+    targetXml?: string;
+    /** The declared config the source and target are imported under. Defaults to the default key. */
+    configKey?: string;
+    /**
+     * The store the test project runs on: the test helpers' default when absent (`useTestStorage`, else the local
+     * store). `sqlite`: the SQLite engine in this process.
+     */
+    storage?: StorageParam;
+    /** Project dev options; `perf: true` makes `document.perf.report()` count the store reads. */
+    dev?: {
+        perf?: boolean;
+    };
+};
+//# sourceMappingURL=create-test-dialecte.types.d.ts.map

package/dist/test/create-test-dialecte.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-dialecte.types.d.ts","sourceRoot":"","sources":["../../src/test/create-test-dialecte.types.ts"],"names":[],"mappings":"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"}

package/dist/test/create-test-helpers-internal.types.d.ts

@@ -0,0 +1,19 @@
+import { BaseXmlTestCase, TestCases } from './run-test-cases.type';
+import { AnyDialecteConfig } from '../types';
+/** The schema assertions of one config, named for the violation messages. */
+export type CreateSchemaAssertionsParams = {
+    config: AnyDialecteConfig;
+    schemaName: string;
+};
+/** Which schema a fixture is checked against: a case's own config, else the config under the key. */
+export type SchemaAssertionsForParams<GenericConfig extends AnyDialecteConfig> = {
+    configKey: string | undefined;
+    caseConfig?: GenericConfig;
+};
+/** What a runner call gives the fixture checks. */
+export type CheckTestCasesParams<GenericConfig extends AnyDialecteConfig> = {
+    testCases: TestCases<BaseXmlTestCase>;
+    configKey?: string;
+    dialecteConfig?: GenericConfig;
+};
+//# sourceMappingURL=create-test-helpers-internal.types.d.ts.map

package/dist/test/create-test-helpers-internal.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-helpers-internal.types.d.ts","sourceRoot":"","sources":["../../src/test/create-test-helpers-internal.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,6EAA6E;AAC7E,MAAM,MAAM,4BAA4B,GAAG;IAC1C,MAAM,EAAE,iBAAiB,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,qGAAqG;AACrG,MAAM,MAAM,yBAAyB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAChF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,UAAU,CAAC,EAAE,aAAa,CAAA;CAC1B,CAAA;AAED,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,CAAC,aAAa,SAAS,iBAAiB,IAAI;IAC3E,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAA;IACrC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,cAAc,CAAC,EAAE,aAAa,CAAA;CAC9B,CAAA"}

package/dist/test/create-test-helpers.d.ts

@@ -0,0 +1,13 @@
+import { CreateTestHelpersParams, TestHelpers } from './create-test-helpers.types';
+import { ExtensionModules } from '../document';
+import { AnyDialecteConfig } from '../types';
+/**
+ * Every test helper a dialecte needs, derived from its declaration: the runner, the test project,
+ * the record factory, the XPath assertions and the schema assertions. A fixture is checked against
+ * the schema of the config it is imported under, then by the dialecte's extra checks, before a
+ * case or a test project uses it.
+ *
+ * @intent get every test helper of a dialecte, set up a dialecte package's tests, check fixtures against the schema
+ */
+export declare function createTestHelpers<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string>(params: CreateTestHelpersParams<GenericConfig, GenericModules, GenericConfigKey>): TestHelpers<GenericConfig, GenericModules>;
+//# sourceMappingURL=create-test-helpers.d.ts.map

package/dist/test/create-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-helpers.d.ts","sourceRoot":"","sources":["../../src/test/create-test-helpers.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACX,uBAAuB,EAEvB,WAAW,EAEX,MAAM,6BAA6B,CAAA;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAYhD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC9D,gBAAgB,SAAS,MAAM,GAAG,MAAM,EAExC,MAAM,EAAE,uBAAuB,CAAC,aAAa,EAAE,cAAc,EAAE,gBAAgB,CAAC,GAC9E,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,CAkF5C"}

package/dist/test/create-test-helpers.types.d.ts

@@ -0,0 +1,50 @@
+import { createXmlSchemaAssertions } from './assert-valid-xml';
+import { XmlAssertions } from './assert-xml';
+import { DeclaredTestRunnerParams, TestProjectOptions, TestProjectResult } from './create-test-dialecte.types';
+import { BaseXmlTestCase, TestCases, TestRunner } from './run-test-cases.type';
+import { createTestRecordFactory } from './test-record';
+import { ExtensionModules } from '../document';
+import { AnyDialecteConfig } from '../types';
+export type XmlSchemaAssertions = ReturnType<typeof createXmlSchemaAssertions>;
+/**
+ * A dialecte's own fixture checks, run once core's schema check has passed (scl's coherent
+ * references). Each throws to refuse.
+ */
+export type TestHelperExtraChecks = {
+    /** On a runner call's cases, before the suite runs. */
+    testCases?: (params: {
+        testCases: TestCases<BaseXmlTestCase>;
+        configKey: string;
+    }) => void;
+    /** On a test project's source, then its target. */
+    fixture?: (params: {
+        xml: string;
+        label: 'sourceXml' | 'targetXml';
+        configKey: string;
+    }) => void;
+};
+export type CreateTestHelpersParams<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>, GenericConfigKey extends string = string> = DeclaredTestRunnerParams<GenericConfig, GenericModules, GenericConfigKey> & {
+    /** Names the schema in fixture violation messages. Defaults to the dialecte's id. */
+    schemaName?: string;
+    extraChecks?: TestHelperExtraChecks;
+};
+export type TestHelperProjectParams = TestProjectOptions & {
+    /** Why this call's fixtures skip the extra checks; core's schema check still runs. */
+    skipExtraChecks?: string;
+};
+/**
+ * Every test helper of a declared dialecte. The runner and the test project check each fixture
+ * against the schema of the config it is imported under, then run the extra checks.
+ */
+export type TestHelpers<GenericConfig extends AnyDialecteConfig, GenericModules extends ExtensionModules = Record<never, never>> = {
+    /**
+     * Each case's XML is checked before the suite runs, every invalid case at once: against the
+     * call's `dialecteConfig` when it passes one, else the config under its `configKey`.
+     */
+    runTestCases: TestRunner<GenericConfig, GenericModules>;
+    /** The source and target are checked against the schema (required attributes may be left out). */
+    createTestProject: (params: TestHelperProjectParams) => Promise<TestProjectResult<GenericConfig, GenericModules>>;
+    /** Bound to the default config. */
+    createTestRecord: ReturnType<typeof createTestRecordFactory<GenericConfig>>;
+} & XmlAssertions & XmlSchemaAssertions;
+//# sourceMappingURL=create-test-helpers.types.d.ts.map

package/dist/test/create-test-helpers.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-helpers.types.d.ts","sourceRoot":"","sources":["../../src/test/create-test-helpers.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,KAAK,EACX,wBAAwB,EACxB,kBAAkB,EAClB,iBAAiB,EACjB,MAAM,8BAA8B,CAAA;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACnF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IACnC,uDAAuD;IACvD,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IAC1F,mDAAmD;IACnD,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CAChG,CAAA;AAED,MAAM,MAAM,uBAAuB,CAClC,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,EAC9D,gBAAgB,SAAS,MAAM,GAAG,MAAM,IACrC,wBAAwB,CAAC,aAAa,EAAE,cAAc,EAAE,gBAAgB,CAAC,GAAG;IAC/E,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,qBAAqB,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,GAAG;IAC1D,sFAAsF;IACtF,eAAe,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,CACtB,aAAa,SAAS,iBAAiB,EACvC,cAAc,SAAS,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,IAC3D;IACH;;;OAGG;IACH,YAAY,EAAE,UAAU,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;IACvD,kGAAkG;IAClG,iBAAiB,EAAE,CAClB,MAAM,EAAE,uBAAuB,KAC3B,OAAO,CAAC,iBAAiB,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC,CAAA;IAC9D,mCAAmC;IACnC,gBAAgB,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,aAAa,CAAC,CAAC,CAAA;CAC3E,GAAG,aAAa,GAChB,mBAAmB,CAAA"}

package/dist/test/fixtures/test-entry-scan-constraint.d.ts

@@ -0,0 +1,3 @@
+import { EdgeRow } from './test-entry-scan-edges.types';
+export declare function constrainedRow<GenericRow extends EdgeRow>(): void;
+//# sourceMappingURL=test-entry-scan-constraint.d.ts.map

package/dist/test/fixtures/test-entry-scan-constraint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-entry-scan-constraint.d.ts","sourceRoot":"","sources":["../../../src/test/fixtures/test-entry-scan-constraint.ts"],"names":[],"mappings":"AAAA,8GAA8G;AAE9G,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAG5D,wBAAgB,cAAc,CAAC,UAAU,SAAS,OAAO,KAAK,IAAI,CAEjE"}