@hotmeshio/long-tail 0.30.1 → 0.30.3

package/build/services/scan-code/sql.js

@@ -18,8 +18,9 @@ SELECT * FROM lt_config_scan_actions WHERE scheme_version = $1 AND category = $2
 exports.UPSERT_SCHEME = `\
 INSERT INTO lt_config_scan_schemes
   (version, name, description, target_facet, encoding, delimiter, target_length,
-   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope,
+   patterns, precedes_gtin, target_match)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 ON CONFLICT (version) DO UPDATE SET
   name = EXCLUDED.name,
   description = EXCLUDED.description,
@@ -31,6 +32,9 @@ ON CONFLICT (version) DO UPDATE SET
   grant_ttl_seconds = EXCLUDED.grant_ttl_seconds,
   grant_max_uses = EXCLUDED.grant_max_uses,
   grant_scope = EXCLUDED.grant_scope,
+  patterns = EXCLUDED.patterns,
+  precedes_gtin = EXCLUDED.precedes_gtin,
+  target_match = EXCLUDED.target_match,
   enabled = EXCLUDED.enabled
 RETURNING *`;
 exports.DELETE_SCHEME = `\
@@ -54,8 +58,9 @@ DELETE FROM lt_config_scan_actions WHERE scheme_version = $1 AND category = $2`;
 exports.SEED_SCHEME = `\
 INSERT INTO lt_config_scan_schemes
   (version, name, description, target_facet, encoding, delimiter, target_length,
-   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope,
+   patterns, precedes_gtin, target_match)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 ON CONFLICT (version) DO NOTHING`;
 exports.SEED_ACTION = `\
 INSERT INTO lt_config_scan_actions
@@ -73,8 +78,9 @@ ON CONFLICT (scheme_version, category) DO NOTHING`;
 exports.APPLY_SCHEME = `\
 INSERT INTO lt_config_scan_schemes
   (version, name, description, target_facet, encoding, delimiter, target_length,
-   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+   kind, grant_ttl_seconds, grant_max_uses, enabled, grant_scope,
+   patterns, precedes_gtin, target_match)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 ON CONFLICT (version) DO UPDATE SET
   name = EXCLUDED.name,
   description = EXCLUDED.description,
@@ -86,6 +92,9 @@ ON CONFLICT (version) DO UPDATE SET
   grant_ttl_seconds = EXCLUDED.grant_ttl_seconds,
   grant_max_uses = EXCLUDED.grant_max_uses,
   grant_scope = EXCLUDED.grant_scope,
+  patterns = EXCLUDED.patterns,
+  precedes_gtin = EXCLUDED.precedes_gtin,
+  target_match = EXCLUDED.target_match,
   enabled = EXCLUDED.enabled,
   updated_at = NOW()
 WHERE (lt_config_scan_schemes.name, lt_config_scan_schemes.description,
@@ -93,12 +102,14 @@ WHERE (lt_config_scan_schemes.name, lt_config_scan_schemes.description,
        lt_config_scan_schemes.delimiter, lt_config_scan_schemes.target_length,
        lt_config_scan_schemes.kind, lt_config_scan_schemes.grant_ttl_seconds,
        lt_config_scan_schemes.grant_max_uses, lt_config_scan_schemes.enabled,
-       lt_config_scan_schemes.grant_scope)
+       lt_config_scan_schemes.grant_scope, lt_config_scan_schemes.patterns,
+       lt_config_scan_schemes.precedes_gtin, lt_config_scan_schemes.target_match)
   IS DISTINCT FROM
       (EXCLUDED.name, EXCLUDED.description, EXCLUDED.target_facet,
        EXCLUDED.encoding, EXCLUDED.delimiter, EXCLUDED.target_length,
        EXCLUDED.kind, EXCLUDED.grant_ttl_seconds, EXCLUDED.grant_max_uses,
-       EXCLUDED.enabled, EXCLUDED.grant_scope)
+       EXCLUDED.enabled, EXCLUDED.grant_scope, EXCLUDED.patterns,
+       EXCLUDED.precedes_gtin, EXCLUDED.target_match)
 RETURNING (xmax = 0) AS inserted`;
 exports.APPLY_ACTION = `\
 INSERT INTO lt_config_scan_actions

package/build/services/scan-code/validate-scheme-pattern.d.ts

@@ -0,0 +1,16 @@
+import { type ScanScheme } from '../../types';
+/**
+ * The pattern-encoding fields and the target match. A pattern scheme
+ * declares 1 to SCAN_PATTERNS_MAX expressions, each compiling and none
+ * matching an empty code; other encodings declare none. A list-valued
+ * target (`member`) applies to action schemes, whose targets resolve
+ * against escalation metadata.
+ */
+export declare function assertValidPatternFields(scheme: Partial<ScanScheme>): void;
+/**
+ * A pattern scheme and an enabled gtin scheme may both read a digits-only
+ * code, so while both are enabled the pattern scheme declares which reads it
+ * first (`precedes_gtin`). Checked from either side of the pair; throws
+ * naming both schemes.
+ */
+export declare function assertGtinOrderDeclared(candidate: Partial<ScanScheme>, others: ScanScheme[]): void;

package/build/services/scan-code/validate-scheme-pattern.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidPatternFields = assertValidPatternFields;
+exports.assertGtinOrderDeclared = assertGtinOrderDeclared;
+const types_1 = require("../../types");
+const scan_code_1 = require("../../shared/scan-code");
+/**
+ * The pattern-encoding fields and the target match. A pattern scheme
+ * declares 1 to SCAN_PATTERNS_MAX expressions, each compiling and none
+ * matching an empty code; other encodings declare none. A list-valued
+ * target (`member`) applies to action schemes, whose targets resolve
+ * against escalation metadata.
+ */
+function assertValidPatternFields(scheme) {
+    const encoding = scheme.encoding ?? types_1.SCAN_ENCODINGS.FIXED;
+    const patterns = scheme.patterns ?? [];
+    if (!Array.isArray(patterns))
+        throw new Error('patterns must be a list of regular expressions');
+    if (encoding === types_1.SCAN_ENCODINGS.PATTERN) {
+        if (patterns.length < 1 || patterns.length > types_1.SCAN_PATTERNS_MAX) {
+            throw new Error(`pattern encoding requires 1 to ${types_1.SCAN_PATTERNS_MAX} patterns`);
+        }
+        for (const pattern of patterns)
+            assertValidPattern(pattern);
+    }
+    else {
+        if (patterns.length > 0)
+            throw new Error('patterns apply only to pattern encoding');
+        if (scheme.precedes_gtin === true)
+            throw new Error('precedes_gtin applies only to pattern encoding');
+    }
+    const match = scheme.target_match ?? types_1.SCAN_TARGET_MATCH.VALUE;
+    if (!Object.values(types_1.SCAN_TARGET_MATCH).includes(match)) {
+        throw new Error(`unknown target_match "${match}"`);
+    }
+    if (match === types_1.SCAN_TARGET_MATCH.MEMBER && (scheme.kind ?? types_1.SCAN_SCHEME_KINDS.ACTION) !== types_1.SCAN_SCHEME_KINDS.ACTION) {
+        throw new Error('target_match member applies only to action schemes');
+    }
+}
+/**
+ * A pattern scheme and an enabled gtin scheme may both read a digits-only
+ * code, so while both are enabled the pattern scheme declares which reads it
+ * first (`precedes_gtin`). Checked from either side of the pair; throws
+ * naming both schemes.
+ */
+function assertGtinOrderDeclared(candidate, others) {
+    if (!(candidate.enabled ?? true))
+        return;
+    const encoding = candidate.encoding ?? types_1.SCAN_ENCODINGS.FIXED;
+    if (encoding === types_1.SCAN_ENCODINGS.PATTERN && candidate.precedes_gtin == null) {
+        const gtin = others.find((s) => s.enabled && s.encoding === types_1.SCAN_ENCODINGS.GTIN);
+        if (gtin) {
+            throw new Error(`gtin scheme ${gtin.version} ("${gtin.name}") also reads digits-only codes; declare precedes_gtin: true to read them with these patterns first, or false to leave them to the gtin scheme`);
+        }
+    }
+    if (encoding === types_1.SCAN_ENCODINGS.GTIN) {
+        const pattern = others.find((s) => s.enabled && s.encoding === types_1.SCAN_ENCODINGS.PATTERN && s.precedes_gtin == null);
+        if (pattern) {
+            throw new Error(`pattern scheme ${pattern.version} ("${pattern.name}") has not declared precedes_gtin; declare whether its patterns read digits-only codes before the gtin scheme, then enable the gtin scheme`);
+        }
+    }
+}
+function assertValidPattern(pattern) {
+    if (typeof pattern !== 'string' || pattern.length === 0) {
+        throw new Error('each pattern must be a non-empty string');
+    }
+    if (pattern.length > types_1.SCAN_PATTERN_MAX_LENGTH) {
+        throw new Error(`pattern "${pattern.slice(0, 32)}…" exceeds ${types_1.SCAN_PATTERN_MAX_LENGTH} characters`);
+    }
+    const regex = (0, scan_code_1.compilePattern)(pattern);
+    if (!regex)
+        throw new Error(`pattern "${pattern}" is not a valid regular expression`);
+    if (regex.test(''))
+        throw new Error(`pattern "${pattern}" matches an empty code`);
+}

package/build/services/scan-code/validate.d.ts

@@ -9,7 +9,9 @@ export declare function assertValidScheme(scheme: Partial<ScanScheme>): void;
  * A scheme must read codes no other scheme reads. Delimited and fixed
  * schemes are told apart by their version prefix; a gtin scheme has none,
  * so there is at most one, and no enabled fixed scheme may accept a GTIN
- * length while it is enabled. Throws naming both schemes.
+ * length while it is enabled. Pattern schemes read only codes no prefixed
+ * scheme reads, lowest version first, and beside an enabled gtin scheme
+ * they declare `precedes_gtin`. Throws naming both schemes.
  */
 export declare function assertSchemesCoexist(candidate: Partial<ScanScheme>, existing: ScanScheme[]): void;
 /** Identity rules never walk steps — their fallback is the unknown-badge screen. */

package/build/services/scan-code/validate.js

@@ -10,6 +10,7 @@ const facet_sql_1 = require("../escalation/facet-sql");
 const validate_subject_1 = require("./validate-subject");
 const validate_query_1 = require("./validate-query");
 const validate_facts_1 = require("./validate-facts");
+const validate_scheme_pattern_1 = require("./validate-scheme-pattern");
 const VALID_VERBS = new Set(Object.values(types_1.SCAN_VERBS));
 /** Double-scan selection tokens — short, label-printable, never scheme-shaped. */
 const CHOICE_CODE = /^[A-Za-z0-9_-]{1,32}$/;
@@ -68,15 +69,19 @@ function assertValidScheme(scheme) {
         || (scheme.grant_scope ?? types_1.SCAN_GRANT_SCOPES.ACTION) !== types_1.SCAN_GRANT_SCOPES.ACTION) {
         throw new Error('grant policy applies only to identity schemes');
     }
+    (0, validate_scheme_pattern_1.assertValidPatternFields)(scheme);
 }
 /**
  * A scheme must read codes no other scheme reads. Delimited and fixed
  * schemes are told apart by their version prefix; a gtin scheme has none,
  * so there is at most one, and no enabled fixed scheme may accept a GTIN
- * length while it is enabled. Throws naming both schemes.
+ * length while it is enabled. Pattern schemes read only codes no prefixed
+ * scheme reads, lowest version first, and beside an enabled gtin scheme
+ * they declare `precedes_gtin`. Throws naming both schemes.
  */
 function assertSchemesCoexist(candidate, existing) {
     const others = existing.filter((s) => s.version !== candidate.version);
+    (0, validate_scheme_pattern_1.assertGtinOrderDeclared)(candidate, others);
     const encoding = candidate.encoding ?? types_1.SCAN_ENCODINGS.FIXED;
     const enabled = candidate.enabled ?? true;
     if (encoding === types_1.SCAN_ENCODINGS.GTIN) {

package/build/services/scan-code/write.d.ts

@@ -11,6 +11,9 @@ export interface ScanSchemeInput {
     grant_ttl_seconds?: number | null;
     grant_max_uses?: number;
     grant_scope?: ScanScheme['grant_scope'];
+    patterns?: string[];
+    precedes_gtin?: boolean | null;
+    target_match?: ScanScheme['target_match'];
     enabled?: boolean;
 }
 export interface ScanRuleInput {

package/build/services/scan-code/write.js

@@ -32,6 +32,9 @@ function schemeParams(input) {
         input.grant_max_uses ?? 0,
         input.enabled ?? true,
         input.grant_scope ?? types_1.SCAN_GRANT_SCOPES.ACTION,
+        JSON.stringify(input.patterns ?? []),
+        input.encoding === types_1.SCAN_ENCODINGS.PATTERN ? input.precedes_gtin ?? null : null,
+        input.target_match ?? types_1.SCAN_TARGET_MATCH.VALUE,
     ];
 }
 function ruleParams(input) {

package/build/shared/scan-code/index.d.ts

@@ -1,2 +1,3 @@
-export { parseScanCode, fixedCodeLengths, type ParseableScheme, type ParsedCode, type ScanParseFailure, type ScanParseResult, } from './parse';
+export { parseScanCode, fixedCodeLengths, compilePattern, patternsMatch, PATTERN_CODE_MAX_LENGTH, unanchorPattern, type ParseableScheme, type ParsedCode, type ScanParseFailure, type ScanParseResult, } from './parse';
+export { facetHolds, facetTarget } from './target';
 export { isValidGtin, normalizeGtin, displayGtin, GTIN_CODE_LENGTHS } from './gtin';

package/build/shared/scan-code/index.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GTIN_CODE_LENGTHS = exports.displayGtin = exports.normalizeGtin = exports.isValidGtin = exports.fixedCodeLengths = exports.parseScanCode = void 0;
+exports.GTIN_CODE_LENGTHS = exports.displayGtin = exports.normalizeGtin = exports.isValidGtin = exports.facetTarget = exports.facetHolds = exports.unanchorPattern = exports.PATTERN_CODE_MAX_LENGTH = exports.patternsMatch = exports.compilePattern = exports.fixedCodeLengths = exports.parseScanCode = void 0;
 var parse_1 = require("./parse");
 Object.defineProperty(exports, "parseScanCode", { enumerable: true, get: function () { return parse_1.parseScanCode; } });
 Object.defineProperty(exports, "fixedCodeLengths", { enumerable: true, get: function () { return parse_1.fixedCodeLengths; } });
+Object.defineProperty(exports, "compilePattern", { enumerable: true, get: function () { return parse_1.compilePattern; } });
+Object.defineProperty(exports, "patternsMatch", { enumerable: true, get: function () { return parse_1.patternsMatch; } });
+Object.defineProperty(exports, "PATTERN_CODE_MAX_LENGTH", { enumerable: true, get: function () { return parse_1.PATTERN_CODE_MAX_LENGTH; } });
+Object.defineProperty(exports, "unanchorPattern", { enumerable: true, get: function () { return parse_1.unanchorPattern; } });
+var target_1 = require("./target");
+Object.defineProperty(exports, "facetHolds", { enumerable: true, get: function () { return target_1.facetHolds; } });
+Object.defineProperty(exports, "facetTarget", { enumerable: true, get: function () { return target_1.facetTarget; } });
 var gtin_1 = require("./gtin");
 Object.defineProperty(exports, "isValidGtin", { enumerable: true, get: function () { return gtin_1.isValidGtin; } });
 Object.defineProperty(exports, "normalizeGtin", { enumerable: true, get: function () { return gtin_1.normalizeGtin; } });

package/build/shared/scan-code/parse.d.ts

@@ -2,9 +2,13 @@
 export interface ParseableScheme {
     version: number;
     name: string;
-    encoding: 'fixed' | 'delimited' | 'gtin';
+    encoding: 'fixed' | 'delimited' | 'gtin' | 'pattern';
     delimiter: string;
     target_length: number | null;
+    /** Pattern encoding: regular expressions over the whole code. */
+    patterns?: string[];
+    /** Pattern encoding: true reads a digits-only code before the gtin scheme does. */
+    precedes_gtin?: boolean | null;
     enabled: boolean;
 }
 export interface ParsedCode {
@@ -27,6 +31,12 @@ export type ScanParseResult<S extends ParseableScheme = ParseableScheme> = {
     ok: false;
     failure: ScanParseFailure;
 };
+/**
+ * The longest code a pattern scheme reads. Declared expressions run only on
+ * codes up to this length, which bounds their cost on any input; carrier
+ * tracking numbers run to 34 characters.
+ */
+export declare const PATTERN_CODE_MAX_LENGTH = 64;
 /**
  * Parse a raw scan string against the configured schemes.
  *
@@ -40,7 +50,18 @@ export type ScanParseResult<S extends ParseableScheme = ParseableScheme> = {
  * when a gtin scheme is configured and its check digit holds: the target is
  * the 14-digit GTIN and the category is '0'. Config validation keeps fixed
  * and gtin lengths apart, so the order here never decides a real code.
+ *
+ * A code no prefixed scheme reads is matched against the pattern schemes'
+ * declared expressions, lowest version first: the target is the code as
+ * scanned and the category is '0'. A pattern scheme with `precedes_gtin`
+ * reads a digits-only code before the gtin scheme does.
  */
 export declare function parseScanCode<S extends ParseableScheme>(raw: string, schemes: S[]): ScanParseResult<S>;
+/** True when the code is within the pattern length and one of the expressions matches all of it. */
+export declare function patternsMatch(patterns: string[], code: string): boolean;
+/** A declared expression anchored to the whole code; null when it does not compile. */
+export declare function compilePattern(pattern: string): RegExp | null;
+/** The expression without one leading `^` and one unescaped trailing `$`. */
+export declare function unanchorPattern(pattern: string): string;
 /** The total code lengths a fixed scheme accepts (with and without the check-digit slack). */
 export declare function fixedCodeLengths(scheme: Pick<ParseableScheme, 'target_length'>): number[];

package/build/shared/scan-code/parse.js

@@ -2,10 +2,21 @@
 // Scan-code parsing. Pure and isomorphic: the server parses every scan with
 // it, and the dashboard parses locally to route a scan into an open form.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PATTERN_CODE_MAX_LENGTH = void 0;
 exports.parseScanCode = parseScanCode;
+exports.patternsMatch = patternsMatch;
+exports.compilePattern = compilePattern;
+exports.unanchorPattern = unanchorPattern;
 exports.fixedCodeLengths = fixedCodeLengths;
 const gtin_1 = require("./gtin");
 const GTIN_CATEGORY = '0';
+const PATTERN_CATEGORY = '0';
+/**
+ * The longest code a pattern scheme reads. Declared expressions run only on
+ * codes up to this length, which bounds their cost on any input; carrier
+ * tracking numbers run to 34 characters.
+ */
+exports.PATTERN_CODE_MAX_LENGTH = 64;
 /**
  * Parse a raw scan string against the configured schemes.
  *
@@ -19,16 +30,31 @@ const GTIN_CATEGORY = '0';
  * when a gtin scheme is configured and its check digit holds: the target is
  * the 14-digit GTIN and the category is '0'. Config validation keeps fixed
  * and gtin lengths apart, so the order here never decides a real code.
+ *
+ * A code no prefixed scheme reads is matched against the pattern schemes'
+ * declared expressions, lowest version first: the target is the code as
+ * scanned and the category is '0'. A pattern scheme with `precedes_gtin`
+ * reads a digits-only code before the gtin scheme does.
  */
 function parseScanCode(raw, schemes) {
     const code = raw.trim();
     if (!code) {
         return { ok: false, failure: { reason: 'empty', detail: 'empty scan code' } };
     }
+    const prefixed = parsePrefixed(code, schemes);
+    if (prefixed.ok)
+        return prefixed;
+    return parsePattern(code, schemes, false) ?? prefixed;
+}
+/** The fixed, gtin and delimited reading of a code, with the gtin-first pattern schemes. */
+function parsePrefixed(code, schemes) {
     if (/^[0-9]+$/.test(code)) {
         const fixed = schemes.find((s) => s.encoding === 'fixed' && s.version === Number(code.slice(0, 2)));
         const fixedFits = fixed?.enabled && fitsFixed(code, fixed);
         if (!fixedFits) {
+            const first = parsePattern(code, schemes, true);
+            if (first)
+                return first;
             const gtin = parseGtin(code, schemes);
             if (gtin)
                 return gtin;
@@ -58,6 +84,9 @@ function parseScanCode(raw, schemes) {
     if (scheme.encoding === 'gtin') {
         return malformed(scheme, 'reads manufacturer barcodes, which carry no scheme prefix');
     }
+    if (scheme.encoding === 'pattern') {
+        return malformed(scheme, 'reads codes by its declared patterns, which carry no scheme prefix');
+    }
     if (scheme.encoding === 'delimited') {
         return parseDelimited(code, version, scheme);
     }
@@ -87,6 +116,55 @@ function parseGtin(code, schemes) {
         scheme: gtin,
     };
 }
+/**
+ * The pattern scheme whose expressions match the whole code, lowest version
+ * first, or null. `gtinFirst` limits the search to schemes that precede gtin.
+ * A match on a disabled scheme only answers when no enabled one matches.
+ */
+function parsePattern(code, schemes, gtinFirst) {
+    const matching = schemes
+        .filter((s) => s.encoding === 'pattern' && (!gtinFirst || s.precedes_gtin))
+        .filter((s) => patternsMatch(s.patterns ?? [], code))
+        .sort((a, b) => a.version - b.version);
+    const scheme = matching.find((s) => s.enabled) ?? matching[0];
+    if (!scheme)
+        return null;
+    if (!scheme.enabled) {
+        return {
+            ok: false,
+            failure: { reason: 'scheme_disabled', detail: `scan scheme ${scheme.version} ("${scheme.name}") is disabled` },
+        };
+    }
+    return { ok: true, parsed: { version: scheme.version, category: PATTERN_CATEGORY, target: code }, scheme };
+}
+/** True when the code is within the pattern length and one of the expressions matches all of it. */
+function patternsMatch(patterns, code) {
+    if (code.length > exports.PATTERN_CODE_MAX_LENGTH)
+        return false;
+    return patterns.some((p) => compilePattern(p)?.test(code));
+}
+const compiled = new Map();
+/** A declared expression anchored to the whole code; null when it does not compile. */
+function compilePattern(pattern) {
+    if (compiled.has(pattern))
+        return compiled.get(pattern);
+    let regex;
+    try {
+        regex = new RegExp(`^(?:${unanchorPattern(pattern)})$`);
+    }
+    catch {
+        regex = null;
+    }
+    compiled.set(pattern, regex);
+    return regex;
+}
+/** The expression without one leading `^` and one unescaped trailing `$`. */
+function unanchorPattern(pattern) {
+    let body = pattern.startsWith('^') ? pattern.slice(1) : pattern;
+    if (body.endsWith('$') && !body.endsWith('\\$'))
+        body = body.slice(0, -1);
+    return body;
+}
 function parseDelimited(code, version, scheme) {
     const d = scheme.delimiter;
     // version(2 digits) <d> category(1 digit) <d> target(rest, non-empty)

package/build/shared/scan-code/target.d.ts

@@ -0,0 +1,4 @@
+/** True when the facet holds the target: equal to it, or a list containing it. */
+export declare function facetHolds(value: unknown, target: string): boolean;
+/** The target a row's facet names: the value, or the first member of a list. */
+export declare function facetTarget(value: unknown): string | null;

package/build/shared/scan-code/target.js

@@ -0,0 +1,14 @@
+"use strict";
+// How a row's facet value matches a scanned target. Pure and isomorphic.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.facetHolds = facetHolds;
+exports.facetTarget = facetTarget;
+/** True when the facet holds the target: equal to it, or a list containing it. */
+function facetHolds(value, target) {
+    return Array.isArray(value) ? value.includes(target) : value === target;
+}
+/** The target a row's facet names: the value, or the first member of a list. */
+function facetTarget(value) {
+    const first = Array.isArray(value) ? value[0] : value;
+    return typeof first === 'string' && first ? first : null;
+}