@aikotools/datafilter 1.0.0

package/dist/src/core/types.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Core type definitions for the datafilter engine
+ */
+/**
+ * A single element in a path through a JSON structure.
+ * Can be a string for object properties or a number for array indices.
+ *
+ * @example
+ * ['data', 'stations', 0, 'name'] → data.stations[0].name
+ */
+export type PathElement = string | number;
+/**
+ * Time unit for time-based comparisons
+ */
+export type TimeUnit = 'milliseconds' | 'seconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years';
+/**
+ * Check if a value matches an expected value (deep equality)
+ */
+export interface CheckValue {
+    value: any;
+}
+/**
+ * Check if a path exists in the object
+ */
+export interface CheckExists {
+    exists: boolean;
+}
+/**
+ * Check if an array contains (or doesn't contain) a specific item
+ */
+export interface CheckArrayElement {
+    itemExists: boolean;
+    item: any;
+}
+/**
+ * Check if an array has a specific size
+ */
+export interface CheckArraySize {
+    type: 'equal' | 'lessThan' | 'greaterThan';
+    size: number;
+}
+/**
+ * Check if a timestamp is within a time range
+ */
+export interface CheckTimeRange {
+    min: string;
+    max: string;
+}
+/**
+ * Check if a numeric value is within a numeric range
+ */
+export interface CheckNumericRange {
+    min: number;
+    max: number;
+}
+/**
+ * A single filter criterion that checks one aspect of the data
+ */
+export interface FilterCriterion {
+    /**
+     * Path to the value to check
+     */
+    path: PathElement[];
+    /**
+     * The check to perform on the value
+     */
+    check: CheckValue | CheckExists | CheckArrayElement | CheckArraySize | CheckTimeRange | CheckNumericRange;
+}
+/**
+ * A single match rule that defines how to match a file
+ */
+export interface SingleMatchRule {
+    /**
+     * Filter criteria - all must match (AND logic)
+     */
+    match: FilterCriterion[];
+    /**
+     * Expected file name/identifier
+     */
+    expected: string;
+    /**
+     * Whether this match is optional
+     */
+    optional?: boolean;
+    /**
+     * Additional metadata for reporting
+     */
+    info?: Record<string, unknown>;
+}
+/**
+ * A wildcard match rule that can match multiple files
+ * NEW: Allows matching arbitrary number of optional files without explicit specification
+ */
+export interface WildcardMatchRule {
+    /**
+     * Filter criteria for wildcard matching
+     */
+    matchAny: FilterCriterion[];
+    /**
+     * Whether to match greedily (as many as possible) or stop after first match
+     * Default: false (stop after first match)
+     */
+    greedy?: boolean;
+    /**
+     * Wildcard matches are always optional
+     */
+    optional: true;
+    /**
+     * Additional metadata for reporting
+     */
+    info?: Record<string, unknown>;
+}
+/**
+ * A match rule can be either a single match or a wildcard match
+ */
+export type MatchRule = SingleMatchRule | WildcardMatchRule;
+/**
+ * Type guard to check if a rule is a wildcard rule
+ */
+export declare function isWildcardRule(rule: MatchRule): rule is WildcardMatchRule;
+/**
+ * Type guard to check if a rule is a single match rule
+ */
+export declare function isSingleMatchRule(rule: MatchRule): rule is SingleMatchRule;
+/**
+ * A group of rules with common filter criteria
+ * NEW: Allows hierarchical filtering where a group of files shares common properties
+ */
+export interface FilterGroup {
+    /**
+     * Common filter criteria that all files in this group must match
+     * These are checked before evaluating individual rules
+     */
+    groupFilter: FilterCriterion[];
+    /**
+     * Rules to apply to files that match the group filter
+     */
+    rules: MatchRule[];
+    /**
+     * Additional metadata for reporting
+     */
+    info?: Record<string, unknown>;
+}
+/**
+ * A file to be filtered
+ */
+export interface JsonFile {
+    /**
+     * File name or identifier
+     */
+    fileName: string;
+    /**
+     * The JSON data
+     */
+    data: any;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of filtering a single file against a criterion
+ */
+export interface FilterCheckResult {
+    /**
+     * Whether the check passed
+     */
+    status: boolean;
+    /**
+     * The check that was performed
+     */
+    checkType: string;
+    /**
+     * Reason for failure (if status is false)
+     */
+    reason?: string | Record<string, unknown>;
+}
+/**
+ * Result of matching a file against a rule
+ */
+export interface MatchResult {
+    /**
+     * Whether all criteria matched
+     */
+    matched: boolean;
+    /**
+     * Individual check results
+     */
+    checks: FilterCheckResult[];
+    /**
+     * The rule that was tested
+     */
+    rule: MatchRule;
+}
+/**
+ * A mapped file with its expected identifier
+ */
+export interface MappedFile {
+    /**
+     * Expected identifier
+     */
+    expected: string;
+    /**
+     * The actual file that was matched
+     */
+    file: JsonFile;
+    /**
+     * Match result details
+     */
+    matchResult: MatchResult;
+    /**
+     * Optional flag from the rule
+     */
+    optional: boolean;
+    /**
+     * Additional info from the rule
+     */
+    info?: Record<string, unknown>;
+}
+/**
+ * A wildcard-matched file (matched via matchAny)
+ */
+export interface WildcardMappedFile {
+    /**
+     * The file that was matched
+     */
+    file: JsonFile;
+    /**
+     * Match result details
+     */
+    matchResult: MatchResult;
+    /**
+     * Additional info from the rule
+     */
+    info?: Record<string, unknown>;
+}
+/**
+ * An unmapped file that didn't match any rule
+ */
+export interface UnmappedFile {
+    /**
+     * The file that couldn't be matched
+     */
+    file: JsonFile;
+    /**
+     * All rules that were tried
+     */
+    attemptedRules: MatchResult[];
+}
+/**
+ * Result of the entire filtering operation
+ */
+export interface FilterResult {
+    /**
+     * Successfully mapped files (expected identifier → actual file)
+     */
+    mapped: MappedFile[];
+    /**
+     * Files matched by wildcard rules
+     */
+    wildcardMatched: WildcardMappedFile[];
+    /**
+     * Files that couldn't be matched to any rule
+     */
+    unmapped: UnmappedFile[];
+    /**
+     * Statistics
+     */
+    stats: {
+        totalFiles: number;
+        mappedFiles: number;
+        wildcardMatchedFiles: number;
+        unmappedFiles: number;
+        totalRules: number;
+        mandatoryRules: number;
+        optionalRules: number;
+    };
+}
+/**
+ * Request for filtering files
+ */
+export interface FilterRequest {
+    /**
+     * Files to be filtered
+     */
+    files: JsonFile[];
+    /**
+     * Matching rules in order (flat structure)
+     * Can be a single rule or an array of rules (for flexible ordering)
+     * Either 'rules' or 'groups' should be provided, not both
+     */
+    rules?: (MatchRule | MatchRule[])[];
+    /**
+     * Grouped rules with common filter criteria (hierarchical structure)
+     * Either 'rules' or 'groups' should be provided, not both
+     * NEW: Allows organizing rules by common criteria (e.g., by line number, event type)
+     */
+    groups?: FilterGroup[];
+    /**
+     * Sort function for ordering files before matching
+     * @param a - First file
+     * @param b - Second file
+     * @returns Negative if a < b, positive if a > b, zero if equal
+     */
+    sortFn?: (a: JsonFile, b: JsonFile) => number;
+    /**
+     * Optional pre-filter criteria that all files must match before rule/group matching
+     * Files that don't match the pre-filter are excluded entirely (not added to unmapped)
+     * Applied before group filters
+     */
+    preFilter?: FilterCriterion[];
+    /**
+     * Optional context for time-based filtering
+     */
+    context?: {
+        startTimeScript?: string;
+        startTimeTest?: string;
+        pathTime?: PathElement[];
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAA;AAEzC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAChB,cAAc,GACd,SAAS,GACT,SAAS,GACT,OAAO,GACP,MAAM,GACN,OAAO,GACP,QAAQ,GACR,OAAO,CAAA;AAEX;;GAEG;AACH,MAAM,WAAW,UAAU;IAEzB,KAAK,EAAE,GAAG,CAAA;CACX;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,UAAU,EAAE,OAAO,CAAA;IAEnB,IAAI,EAAE,GAAG,CAAA;CACV;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,aAAa,CAAA;IAC1C,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,IAAI,EAAE,WAAW,EAAE,CAAA;IAEnB;;OAEG;IACH,KAAK,EACD,UAAU,GACV,WAAW,GACX,iBAAiB,GACjB,cAAc,GACd,cAAc,GACd,iBAAiB,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,KAAK,EAAE,eAAe,EAAE,CAAA;IAExB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,EAAE,eAAe,EAAE,CAAA;IAE3B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAEhB;;OAEG;IACH,QAAQ,EAAE,IAAI,CAAA;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,eAAe,GAAG,iBAAiB,CAAA;AAE3D;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,iBAAiB,CAEzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,eAAe,CAE1E;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,WAAW,EAAE,eAAe,EAAE,CAAA;IAE9B;;OAEG;IACH,KAAK,EAAE,SAAS,EAAE,CAAA;IAElB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IAEH,IAAI,EAAE,GAAG,CAAA;IAET;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAA;IAEf;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IAEjB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;IAEhB;;OAEG;IACH,MAAM,EAAE,iBAAiB,EAAE,CAAA;IAE3B;;OAEG;IACH,IAAI,EAAE,SAAS,CAAA;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAA;IAEd;;OAEG;IACH,WAAW,EAAE,WAAW,CAAA;IAExB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAA;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAA;IAEd;;OAEG;IACH,WAAW,EAAE,WAAW,CAAA;IAExB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,QAAQ,CAAA;IAEd;;OAEG;IACH,cAAc,EAAE,WAAW,EAAE,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,MAAM,EAAE,UAAU,EAAE,CAAA;IAEpB;;OAEG;IACH,eAAe,EAAE,kBAAkB,EAAE,CAAA;IAErC;;OAEG;IACH,QAAQ,EAAE,YAAY,EAAE,CAAA;IAExB;;OAEG;IACH,KAAK,EAAE;QACL,UAAU,EAAE,MAAM,CAAA;QAClB,WAAW,EAAE,MAAM,CAAA;QACnB,oBAAoB,EAAE,MAAM,CAAA;QAC5B,aAAa,EAAE,MAAM,CAAA;QACrB,UAAU,EAAE,MAAM,CAAA;QAClB,cAAc,EAAE,MAAM,CAAA;QACtB,aAAa,EAAE,MAAM,CAAA;KACtB,CAAA;CACF;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,KAAK,EAAE,QAAQ,EAAE,CAAA;IAEjB;;;;OAIG;IACH,KAAK,CAAC,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,CAAA;IAEnC;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;IAEtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,CAAA;IAE7C;;;;OAIG;IACH,SAAS,CAAC,EAAE,eAAe,EAAE,CAAA;IAE7B;;OAEG;IACH,OAAO,CAAC,EAAE;QACR,eAAe,CAAC,EAAE,MAAM,CAAA;QACxB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAA;KACzB,CAAA;CACF"}

package/dist/src/engine/FilterEngine.d.ts

@@ -0,0 +1,84 @@
+import { FilterCriterion, FilterCheckResult } from '../core/types';
+
+/**
+ * Filter engine that evaluates filter criteria against data objects.
+ * Provides various check methods for different types of comparisons.
+ */
+export declare class FilterEngine {
+    /**
+     * Context for time-based filtering
+     */
+    private context?;
+    constructor(context?: {
+        startTimeScript?: string;
+        startTimeTest?: string;
+    });
+    /**
+     * Evaluates a single filter criterion against a data object.
+     *
+     * @param data - The data object to check
+     * @param criterion - The filter criterion to evaluate
+     * @returns FilterCheckResult indicating success or failure
+     */
+    evaluateCriterion(data: any, criterion: FilterCriterion): FilterCheckResult;
+    /**
+     * Checks if a value matches an expected value using deep equality.
+     *
+     * @param data - The data object
+     * @param path - Path to the value
+     * @param check - The value check specification
+     * @returns FilterCheckResult
+     */
+    private checkValue;
+    /**
+     * Checks if a path exists in the data object.
+     *
+     * @param data - The data object
+     * @param path - Path to check
+     * @param check - The exists check specification
+     * @returns FilterCheckResult
+     */
+    private checkExists;
+    /**
+     * Checks if an array contains (or doesn't contain) a specific element.
+     *
+     * @param data - The data object
+     * @param path - Path to the array
+     * @param check - The array element check specification
+     * @returns FilterCheckResult
+     */
+    private checkArrayElement;
+    /**
+     * Checks if an array has the expected size.
+     *
+     * @param data - The data object
+     * @param path - Path to the array
+     * @param check - The array size check specification
+     * @returns FilterCheckResult
+     */
+    private checkArraySize;
+    /**
+     * Checks if a timestamp is within the expected time range.
+     *
+     * @param data - The data object
+     * @param path - Path to the timestamp
+     * @param check - The time range check specification
+     * @returns FilterCheckResult
+     */
+    private checkTimeRange;
+    /**
+     * Checks if a numeric value is within the expected range.
+     *
+     * @param data - The data object
+     * @param path - Path to the numeric value
+     * @param check - The numeric range check specification
+     * @returns FilterCheckResult
+     */
+    private checkNumericRange;
+    /**
+     * Deep equality comparison.
+     * Compares two values recursively for equality.
+     */
+    private deepEqual;
+}
+//# sourceMappingURL=FilterEngine.d.ts.map

package/dist/src/engine/FilterEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterEngine.d.ts","sourceRoot":"","sources":["../../../src/engine/FilterEngine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAOlB,MAAM,eAAe,CAAA;AAGtB;;;GAGG;AACH,qBAAa,YAAY;IACvB;;OAEG;IAEH,OAAO,CAAC,OAAO,CAAC,CAGf;gBAEW,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE;IAI1E;;;;;;OAMG;IAEH,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,eAAe,GAAG,iBAAiB;IAoC3E;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAyClB;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;IA4BnB;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAwDzB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAyEtB;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAqHtB;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAqDzB;;;OAGG;IAEH,OAAO,CAAC,SAAS;CAmClB"}

package/dist/src/engine/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Engine exports
+ */
+export * from './FilterEngine';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/engine/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gBAAgB,CAAA"}

package/dist/src/index.d.ts

@@ -0,0 +1,48 @@
+import { FilterRequest, FilterResult } from './core/types';
+/**
+ * @aikotools/datafilter
+ *
+ * Advanced data filtering engine for JSON file matching in E2E testing
+ */
+export type { PathElement, TimeUnit, CheckValue, CheckExists, CheckArrayElement, CheckArraySize, CheckTimeRange, CheckNumericRange, FilterCriterion, SingleMatchRule, WildcardMatchRule, MatchRule, FilterGroup, JsonFile, FilterCheckResult, MatchResult, MappedFile, WildcardMappedFile, UnmappedFile, FilterResult, FilterRequest, } from './core/types';
+export { isWildcardRule, isSingleMatchRule } from './core/types';
+export { FilterEngine } from './engine';
+export { Matcher } from './matcher';
+export { getValueFromPath, pathExists, getValueOr } from './utils';
+export type { AccessResult } from './utils';
+/**
+ * Convenience function for filtering files with a single call.
+ * Creates a Matcher instance and performs the filtering operation.
+ *
+ * @param request - Filter request containing files, rules/groups, sort function, and context
+ * @returns FilterResult with mapped, wildcardMatched, and unmapped files
+ *
+ * @example
+ * ```typescript
+ * // Using flat rules structure
+ * const result = filterFiles({
+ *   files: jsonFiles,
+ *   rules: [
+ *     { match: [{path: ['type'], check: {value: 'event1'}}], expected: 'event1.json' },
+ *     { matchAny: [{path: ['optional'], check: {exists: true}}], optional: true, greedy: true },
+ *     { match: [{path: ['type'], check: {value: 'event2'}}], expected: 'event2.json' }
+ *   ],
+ *   sortFn: (a, b) => a.data.timestamp - b.data.timestamp
+ * });
+ *
+ * // Using grouped structure
+ * const result = filterFiles({
+ *   files: jsonFiles,
+ *   preFilter: [{path: ['eventType'], check: {value: 'RiFahrt'}}],
+ *   groups: [
+ *     {
+ *       groupFilter: [{path: ['linie'], check: {value: '88888'}}],
+ *       rules: [...]
+ *     }
+ *   ],
+ *   sortFn: (a, b) => a.data.timestamp - b.data.timestamp
+ * });
+ * ```
+ */
+export declare function filterFiles(request: FilterRequest): FilterResult;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,YAAY,EACV,WAAW,EACX,QAAQ,EACR,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,QAAQ,EACR,iBAAiB,EACjB,WAAW,EACX,UAAU,EACV,kBAAkB,EAClB,YAAY,EACZ,YAAY,EACZ,aAAa,GACd,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAGhE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAGnC,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAClE,YAAY,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAI3C,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CA4BhE"}

package/dist/src/matcher/Matcher.d.ts

@@ -0,0 +1,64 @@
+import { JsonFile, MatchRule, FilterResult, MatchResult, FilterCriterion, FilterGroup } from '../core/types';
+
+/**
+ * Matcher system that matches files against rules.
+ * Supports single matches, flexible ordering, and wildcard matches.
+ */
+export declare class Matcher {
+    private engine;
+    constructor(context?: {
+        startTimeScript?: string;
+        startTimeTest?: string;
+    });
+    /**
+     * Matches a single file against a rule.
+     *
+     * @param file - The file to match
+     * @param rule - The rule to match against
+     * @returns MatchResult indicating if all criteria matched
+     */
+    matchFile(file: JsonFile, rule: MatchRule): MatchResult;
+    /**
+     * Applies pre-filter criteria to files, returning only files that match all criteria.
+     *
+     * @param files - Files to filter
+     * @param preFilter - Filter criteria that all files must match
+     * @returns Filtered files that match all preFilter criteria
+     */
+    private applyPreFilter;
+    /**
+     * Main filtering function that processes files according to rules.
+     *
+     * @param files - Files to filter
+     * @param rules - Matching rules (can include arrays for flexible ordering)
+     * @param sortFn - Optional sort function for file ordering
+     * @param preFilter - Optional pre-filter criteria (files not matching are excluded)
+     * @returns FilterResult with mapped, wildcardMatched, and unmapped files
+     */
+    filterFiles(files: JsonFile[], rules: (MatchRule | MatchRule[])[], sortFn?: (a: JsonFile, b: JsonFile) => number, preFilter?: FilterCriterion[]): FilterResult;
+    /**
+     * Counts total number of rules (flattening arrays)
+     */
+    private countRules;
+    /**
+     * Counts mandatory rules
+     */
+    private countMandatoryRules;
+    /**
+     * Counts optional rules
+     */
+    private countOptionalRules;
+    /**
+     * Filtering function for grouped rules with common filter criteria.
+     * Files are first filtered by preFilter (if provided), then matched against
+     * group filters, and finally processed by the group's rules.
+     *
+     * @param files - Files to filter
+     * @param groups - Filter groups with common criteria and rules
+     * @param sortFn - Optional sort function for file ordering
+     * @param preFilter - Optional pre-filter criteria (files not matching are excluded)
+     * @returns FilterResult with mapped, wildcardMatched, and unmapped files
+     */
+    filterFilesWithGroups(files: JsonFile[], groups: FilterGroup[], sortFn?: (a: JsonFile, b: JsonFile) => number, preFilter?: FilterCriterion[]): FilterResult;
+}
+//# sourceMappingURL=Matcher.d.ts.map

package/dist/src/matcher/Matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matcher.d.ts","sourceRoot":"","sources":["../../../src/matcher/Matcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,YAAY,EAIZ,WAAW,EACX,eAAe,EACf,WAAW,EACZ,MAAM,eAAe,CAAA;AAItB;;;GAGG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAAc;gBAEhB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE;IAI1E;;;;;;OAMG;IACH,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,GAAG,WAAW;IAgBvD;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAStB;;;;;;;;OAQG;IACH,WAAW,CACT,KAAK,EAAE,QAAQ,EAAE,EACjB,KAAK,EAAE,CAAC,SAAS,GAAG,SAAS,EAAE,CAAC,EAAE,EAClC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,EAC7C,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,YAAY;IAuKf;;OAEG;IACH,OAAO,CAAC,UAAU;IASlB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAS3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;;;;;;;;;OAUG;IACH,qBAAqB,CACnB,KAAK,EAAE,QAAQ,EAAE,EACjB,MAAM,EAAE,WAAW,EAAE,EACrB,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,MAAM,EAC7C,SAAS,CAAC,EAAE,eAAe,EAAE,GAC5B,YAAY;CA+DhB"}

package/dist/src/matcher/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Matcher exports
+ */
+export * from './Matcher';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/matcher/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/matcher/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,WAAW,CAAA"}

package/dist/src/utils/ObjectAccess.d.ts

@@ -0,0 +1,72 @@
+import { PathElement } from '../core/types';
+
+/**
+ * Result of accessing a value from an object
+ */
+export interface AccessResult {
+    /**
+     * The value found at the path (undefined if not found)
+     */
+    value: any;
+    /**
+     * Whether the path was successfully resolved
+     */
+    found: boolean;
+    /**
+     * Error message if path couldn't be resolved
+     */
+    error?: string;
+    /**
+     * The portion of the path that was successfully resolved
+     */
+    validPath: PathElement[];
+}
+/**
+ * Retrieves a value from an object following the specified path.
+ * Supports nested objects and arrays.
+ *
+ * @param object - The object to access
+ * @param path - Array of property names and array indices
+ * @returns AccessResult containing the value and status
+ *
+ * @example
+ * ```typescript
+ * const obj = { data: { stations: [{ name: 'Berlin' }, { name: 'Munich' }] } };
+ * const result = getValueFromPath(obj, ['data', 'stations', 1, 'name']);
+ * // result.value === 'Munich'
+ * // result.found === true
+ * ```
+ */
+export declare function getValueFromPath(object: any, path: PathElement[]): AccessResult;
+/**
+ * Checks if a path exists in an object.
+ *
+ * @param object - The object to check
+ * @param path - Array of property names and array indices
+ * @returns true if the path exists and has a defined value
+ *
+ * @example
+ * ```typescript
+ * const obj = { data: { value: 42 } };
+ * pathExists(obj, ['data', 'value']); // true
+ * pathExists(obj, ['data', 'missing']); // false
+ * ```
+ */
+export declare function pathExists(object: any, path: PathElement[]): boolean;
+/**
+ * Gets a value from an object with a default fallback.
+ *
+ * @param object - The object to access
+ * @param path - Array of property names and array indices
+ * @param defaultValue - Value to return if path doesn't exist
+ * @returns The value at the path, or defaultValue if not found
+ *
+ * @example
+ * ```typescript
+ * const obj = { data: { value: 42 } };
+ * getValueOr(obj, ['data', 'value'], 0); // 42
+ * getValueOr(obj, ['data', 'missing'], 0); // 0
+ * ```
+ */
+export declare function getValueOr<T>(object: any, path: PathElement[], defaultValue: T): T;
+//# sourceMappingURL=ObjectAccess.d.ts.map

package/dist/src/utils/ObjectAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectAccess.d.ts","sourceRoot":"","sources":["../../../src/utils/ObjectAccess.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAEhD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IAEH,KAAK,EAAE,GAAG,CAAA;IAEV;;OAEG;IACH,KAAK,EAAE,OAAO,CAAA;IAEd;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,SAAS,EAAE,WAAW,EAAE,CAAA;CACzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAE9B,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,WAAW,EAAE,GAClB,YAAY,CAwFd;AAED;;;;;;;;;;;;;GAaG;AAEH,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,CAGpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAE1B,MAAM,EAAE,GAAG,EACX,IAAI,EAAE,WAAW,EAAE,EACnB,YAAY,EAAE,CAAC,GACd,CAAC,CAGH"}

package/dist/src/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Utility exports
+ */
+export * from './ObjectAccess';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,gBAAgB,CAAA"}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Torsten Link <torstenlink@gmx.de> (https://nanook.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.