@milaboratories/pl-model-common 1.25.1 → 1.25.3

package/dist/drivers/pframe/spec/selectors.d.ts

@@ -1,5 +1,8 @@
-import { type PObjectSpec } from "../../../pool";
-import type { AxisId, AxisValueType, Domain, PColumnSpec, ValueType } from "./spec";
+import { PObjectSpec } from "../../../pool/spec.js";
+import "../../../pool/index.js";
+import { AxisId, AxisValueType, Domain, PColumnSpec, ValueType } from "./spec.js";
+
+//#region src/drivers/pframe/spec/selectors.d.ts
 /**
  * Defines a pattern for matching axes within the PFrame data model.
  *
@@ -11,151 +14,151 @@ import type { AxisId, AxisValueType, Domain, PColumnSpec, ValueType } from "./sp
  * This interface is used in various selection and matching operations
  * throughout the PFrame system, such as column queries and axis lookups.
  */
-export interface AxisSelector {
-    /**
-     * Optional value type to match against.
-     * When specified, only axes with this exact type will match.
-     * Can be a single type or an array of types to match against any of them.
-     * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.
-     */
-    type?: ValueType | ValueType[];
-    /**
-     * Optional name to match against.
-     * When specified, only axes with this exact name will match.
-     */
-    name?: string;
-    /**
-     * Optional domain key-value pairs to match against.
-     * Domains provide additional context to uniquely identify an axis beyond its name and type.
-     * When specified, an axis will match only if it contains all the key-value pairs defined here.
-     * An axis with additional domain entries not present in this selector will still match.
-     */
-    domain?: Record<string, string>;
+interface AxisSelector {
+  /**
+   * Optional value type to match against.
+   * When specified, only axes with this exact type will match.
+   * Can be a single type or an array of types to match against any of them.
+   * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.
+   */
+  type?: ValueType | ValueType[];
+  /**
+   * Optional name to match against.
+   * When specified, only axes with this exact name will match.
+   */
+  name?: string;
+  /**
+   * Optional domain key-value pairs to match against.
+   * Domains provide additional context to uniquely identify an axis beyond its name and type.
+   * When specified, an axis will match only if it contains all the key-value pairs defined here.
+   * An axis with additional domain entries not present in this selector will still match.
+   */
+  domain?: Record<string, string>;
 }
 /** Single axis selector */
-export interface SingleAxisSelector {
-    /** Axis name (required) */
-    name: string;
-    /** Axis type (optional) */
-    type?: AxisValueType;
-    /** Domain requirements (optional) */
-    domain?: Domain;
-    /** Parent axes requirements (optional) */
-    parentAxes?: SingleAxisSelector[];
+interface SingleAxisSelector {
+  /** Axis name (required) */
+  name: string;
+  /** Axis type (optional) */
+  type?: AxisValueType;
+  /** Domain requirements (optional) */
+  domain?: Domain;
+  /** Parent axes requirements (optional) */
+  parentAxes?: SingleAxisSelector[];
 }
 /**
  * Reference to an axis by its numerical index within the anchor column's axes array
  * Format: [anchorId, axisIndex]
  */
-export type AnchorAxisRefByIdx = {
-    anchor: string;
-    idx: number;
+type AnchorAxisRefByIdx = {
+  anchor: string;
+  idx: number;
 };
 /**
  * Reference to an axis by its name within the anchor column
  * Format: [anchorId, axisName]
  */
-export type AnchorAxisRefByName = {
-    anchor: string;
-    name: string;
+type AnchorAxisRefByName = {
+  anchor: string;
+  name: string;
 };
 /**
  * Reference to an axis using an AxisId matcher within the anchor
  * Format: [anchorId, axisMatcher]
  */
-export type AnchorAxisRefByMatcher = {
-    anchor: string;
-    id: AxisId;
+type AnchorAxisRefByMatcher = {
+  anchor: string;
+  id: AxisId;
 };
 /**
  * Basic anchor axis reference that can be either by index or a direct AxisId
  */
-export type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;
+type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;
 /** Union of all possible ways to reference an axis in an anchored context  */
-export type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;
+type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;
 /** Reference to a domain value through an anchor */
-export type AnchorDomainRef = {
-    anchor: string;
+type AnchorDomainRef = {
+  anchor: string;
 };
 /**
  * Domain value that can be either a direct string value or a reference to a domain through an anchor
  * Used to establish domain context that can be resolved relative to other anchored columns
  */
-export type ADomain = string | AnchorDomainRef;
+type ADomain = string | AnchorDomainRef;
 /**
  * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor
  * Allows referring to axes in a way that can be resolved in different contexts
  */
-export type AAxisSelector = AxisSelector | AnchorAxisRef;
+type AAxisSelector = AxisSelector | AnchorAxisRef;
 /**
  * Match resolution strategy for PColumns
  * Specifies how to handle when multiple columns match the criteria
  * (default is "expectSingle")
  */
-export type AnchoredColumnMatchStrategy = "expectSingle" | "expectMultiple" | "takeFirst";
+type AnchoredColumnMatchStrategy = "expectSingle" | "expectMultiple" | "takeFirst";
 /**
  * Matcher for PColumns in an anchored context
  * Supports partial matching on axes, allowing for flexible column discovery
  */
-export interface AnchoredPColumnSelector {
-    /** Optional name of the column to match; can't be used together with namePattern */
-    name?: string;
-    /** Optional regexp pattern for column name matching; can't be used together with name */
-    namePattern?: string;
-    /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */
-    type?: ValueType | ValueType[];
-    /** If specified, the domain values must be anchored to this anchor */
-    domainAnchor?: string;
-    /** Optional domain values to match, can include anchored references, if domainAnchor is specified,
-     * interpreted as additional domains to domain from the anchor */
-    domain?: Record<string, ADomain>;
-    /** Optional axes to match, can include anchored references */
-    axes?: AAxisSelector[];
-    /** When true, allows matching if only a subset of axes match */
-    partialAxesMatch?: boolean;
-    /** Optional annotations to match with exact values */
-    annotations?: Record<string, string>;
-    /** Optional annotation patterns to match with regex patterns */
-    annotationPatterns?: Record<string, string>;
-    /** Match resolution strategy, default is "expectSingle" */
-    matchStrategy?: AnchoredColumnMatchStrategy;
+interface AnchoredPColumnSelector {
+  /** Optional name of the column to match; can't be used together with namePattern */
+  name?: string;
+  /** Optional regexp pattern for column name matching; can't be used together with name */
+  namePattern?: string;
+  /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */
+  type?: ValueType | ValueType[];
+  /** If specified, the domain values must be anchored to this anchor */
+  domainAnchor?: string;
+  /** Optional domain values to match, can include anchored references, if domainAnchor is specified,
+   * interpreted as additional domains to domain from the anchor */
+  domain?: Record<string, ADomain>;
+  /** Optional axes to match, can include anchored references */
+  axes?: AAxisSelector[];
+  /** When true, allows matching if only a subset of axes match */
+  partialAxesMatch?: boolean;
+  /** Optional annotations to match with exact values */
+  annotations?: Record<string, string>;
+  /** Optional annotation patterns to match with regex patterns */
+  annotationPatterns?: Record<string, string>;
+  /** Match resolution strategy, default is "expectSingle" */
+  matchStrategy?: AnchoredColumnMatchStrategy;
 }
 /**
  * Matcher for PColumns in a non-anchored context
  */
-export interface PColumnSelector extends AnchoredPColumnSelector {
-    domainAnchor?: never;
-    domain?: Record<string, string>;
-    axes?: AxisSelector[];
+interface PColumnSelector extends AnchoredPColumnSelector {
+  domainAnchor?: never;
+  domain?: Record<string, string>;
+  axes?: AxisSelector[];
 }
 /**
  * Strict identifier for PColumns in an anchored context
  * Unlike APColumnMatcher, this requires exact matches on domain and axes
  */
-export interface AnchoredPColumnId extends AnchoredPColumnSelector {
-    /** Name is required for exact column identification */
-    name: string;
-    /** No namePattern in ID */
-    namePattern?: never;
-    /** Type is not used in exact column identification */
-    type?: never;
-    /** Full axes specification using only basic references */
-    axes: AnchorAxisIdOrRefBasic[];
-    /** Partial axes matching is not allowed for exact identification */
-    partialAxesMatch?: never;
-    /** Annotations are not used in exact column identification */
-    annotations?: never;
-    /** Annotation patterns are not used in exact column identification */
-    annotationPatterns?: never;
-    /** "Id" implies single match strategy */
-    matchStrategy?: never;
+interface AnchoredPColumnId extends AnchoredPColumnSelector {
+  /** Name is required for exact column identification */
+  name: string;
+  /** No namePattern in ID */
+  namePattern?: never;
+  /** Type is not used in exact column identification */
+  type?: never;
+  /** Full axes specification using only basic references */
+  axes: AnchorAxisIdOrRefBasic[];
+  /** Partial axes matching is not allowed for exact identification */
+  partialAxesMatch?: never;
+  /** Annotations are not used in exact column identification */
+  annotations?: never;
+  /** Annotation patterns are not used in exact column identification */
+  annotationPatterns?: never;
+  /** "Id" implies single match strategy */
+  matchStrategy?: never;
 }
 /**
  * Checks if a given value is an anchored column identifier
  * @param id - The value to check
  * @returns True if the value is an anchored column identifier, false otherwise
  */
-export declare function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnId;
+declare function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnId;
 /**
  * Determines if an axis ID matches an axis selector.
  *
@@ -163,7 +166,7 @@ export declare function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnI
  * @param axis - The AxisId to check against the selector
  * @returns true if the AxisId matches all specified criteria in the selector, false otherwise
  */
-export declare function matchAxis(selector: AxisSelector, axis: AxisId): boolean;
+declare function matchAxis(selector: AxisSelector, axis: AxisId): boolean;
 /**
  * Determines if a given PColumnSpec matches a selector.
  *
@@ -171,12 +174,14 @@ export declare function matchAxis(selector: AxisSelector, axis: AxisId): boolean
  * @param selector - The selector criteria to match against
  * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise
  */
-export declare function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean;
+declare function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean;
 /**
  * Convert a predicate or array of selectors to a single predicate function
  * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,
  *                              or an array of PColumnSelectors, or a single PColumnSelector
  * @returns A function that takes a PColumnSpec and returns a boolean
  */
-export declare function selectorsToPredicate(predicateOrSelectors: PColumnSelector | PColumnSelector[]): (spec: PObjectSpec) => boolean;
+declare function selectorsToPredicate(predicateOrSelectors: PColumnSelector | PColumnSelector[]): (spec: PObjectSpec) => boolean;
+//#endregion
+export { AAxisSelector, ADomain, AnchorAxisIdOrRefBasic, AnchorAxisRef, AnchorAxisRefByIdx, AnchorAxisRefByMatcher, AnchorAxisRefByName, AnchorDomainRef, AnchoredColumnMatchStrategy, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector, SingleAxisSelector, isAnchoredPColumnId, matchAxis, matchPColumn, selectorsToPredicate };
 //# sourceMappingURL=selectors.d.ts.map

package/dist/drivers/pframe/spec/selectors.js

@@ -1,125 +1,87 @@
-import { isPColumnSpec } from '../../../pool/spec.js';
-import { getAxisId } from './spec.js';
+import { getAxisId } from "./spec.js";
+import { isPColumnSpec } from "../../../pool/spec.js";
 
+//#region src/drivers/pframe/spec/selectors.ts
 /**
- * Checks if a given value is an anchored column identifier
- * @param id - The value to check
- * @returns True if the value is an anchored column identifier, false otherwise
- */
+* Checks if a given value is an anchored column identifier
+* @param id - The value to check
+* @returns True if the value is an anchored column identifier, false otherwise
+*/
 function isAnchoredPColumnId(id) {
-    // basic check, can be extended if needed
-    return typeof id === "object" && id !== null && "name" in id && "axes" in id;
+	return typeof id === "object" && id !== null && "name" in id && "axes" in id;
 }
 /**
- * Determines if an axis ID matches an axis selector.
- *
- * @param selector - The selector with criteria to match against
- * @param axis - The AxisId to check against the selector
- * @returns true if the AxisId matches all specified criteria in the selector, false otherwise
- */
+* Determines if an axis ID matches an axis selector.
+*
+* @param selector - The selector with criteria to match against
+* @param axis - The AxisId to check against the selector
+* @returns true if the AxisId matches all specified criteria in the selector, false otherwise
+*/
 function matchAxis(selector, axis) {
-    // Match name if specified
-    if (selector.name !== undefined && selector.name !== axis.name)
-        return false;
-    // Match type if specified
-    if (selector.type !== undefined) {
-        if (Array.isArray(selector.type)) {
-            if (!selector.type.includes(axis.type))
-                return false;
-        }
-        else if (selector.type !== axis.type) {
-            return false;
-        }
-    }
-    // Match domain if specified - using existing logic from matchAxisId
-    if (selector.domain !== undefined) {
-        const axisDomain = axis.domain || {};
-        for (const [key, value] of Object.entries(selector.domain))
-            if (axisDomain[key] !== value)
-                return false;
-    }
-    return true;
+	if (selector.name !== void 0 && selector.name !== axis.name) return false;
+	if (selector.type !== void 0) {
+		if (Array.isArray(selector.type)) {
+			if (!selector.type.includes(axis.type)) return false;
+		} else if (selector.type !== axis.type) return false;
+	}
+	if (selector.domain !== void 0) {
+		const axisDomain = axis.domain || {};
+		for (const [key, value] of Object.entries(selector.domain)) if (axisDomain[key] !== value) return false;
+	}
+	return true;
 }
 /**
- * Determines if a given PColumnSpec matches a selector.
- *
- * @param pcolumn - The PColumnSpec to check against the selector
- * @param selector - The selector criteria to match against
- * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise
- */
+* Determines if a given PColumnSpec matches a selector.
+*
+* @param pcolumn - The PColumnSpec to check against the selector
+* @param selector - The selector criteria to match against
+* @returns true if the PColumnSpec matches all criteria in the selector, false otherwise
+*/
 function matchPColumn(pcolumn, selector) {
-    // Match name if specified
-    if (selector.name !== undefined && pcolumn.name !== selector.name)
-        return false;
-    // Match name pattern if specified
-    if (selector.namePattern !== undefined && !new RegExp(selector.namePattern).test(pcolumn.name))
-        return false;
-    // Match type if specified
-    if (selector.type !== undefined) {
-        if (Array.isArray(selector.type)) {
-            if (!selector.type.includes(pcolumn.valueType))
-                return false;
-        }
-        else if (selector.type !== pcolumn.valueType) {
-            return false;
-        }
-    }
-    // Match domain if specified
-    if (selector.domain !== undefined) {
-        const columnDomain = pcolumn.domain || {};
-        for (const [key, value] of Object.entries(selector.domain))
-            if (columnDomain[key] !== value)
-                return false;
-    }
-    // Match axes if specified
-    if (selector.axes !== undefined) {
-        const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);
-        if (selector.partialAxesMatch) {
-            // For partial matching, all selector axes must match at least one column axis
-            for (const selectorAxis of selector.axes)
-                if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis)))
-                    return false;
-        }
-        else {
-            // For exact matching, column must have the same number of axes and all must match
-            if (pcolumnAxes.length !== selector.axes.length)
-                return false;
-            // Each selector axis must match a corresponding column axis
-            for (let i = 0; i < selector.axes.length; i++)
-                if (!matchAxis(selector.axes[i], pcolumnAxes[i]))
-                    return false;
-        }
-    }
-    // Match annotations if specified
-    if (selector.annotations !== undefined) {
-        const columnAnnotations = pcolumn.annotations || {};
-        for (const [key, value] of Object.entries(selector.annotations))
-            if (columnAnnotations[key] !== value)
-                return false;
-    }
-    // Match annotation patterns if specified
-    if (selector.annotationPatterns !== undefined) {
-        const columnAnnotations = pcolumn.annotations || {};
-        for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {
-            const value = columnAnnotations[key];
-            if (value === undefined || !new RegExp(pattern).test(value))
-                return false;
-        }
-    }
-    return true;
+	if (selector.name !== void 0 && pcolumn.name !== selector.name) return false;
+	if (selector.namePattern !== void 0 && !new RegExp(selector.namePattern).test(pcolumn.name)) return false;
+	if (selector.type !== void 0) {
+		if (Array.isArray(selector.type)) {
+			if (!selector.type.includes(pcolumn.valueType)) return false;
+		} else if (selector.type !== pcolumn.valueType) return false;
+	}
+	if (selector.domain !== void 0) {
+		const columnDomain = pcolumn.domain || {};
+		for (const [key, value] of Object.entries(selector.domain)) if (columnDomain[key] !== value) return false;
+	}
+	if (selector.axes !== void 0) {
+		const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);
+		if (selector.partialAxesMatch) {
+			for (const selectorAxis of selector.axes) if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis))) return false;
+		} else {
+			if (pcolumnAxes.length !== selector.axes.length) return false;
+			for (let i = 0; i < selector.axes.length; i++) if (!matchAxis(selector.axes[i], pcolumnAxes[i])) return false;
+		}
+	}
+	if (selector.annotations !== void 0) {
+		const columnAnnotations = pcolumn.annotations || {};
+		for (const [key, value] of Object.entries(selector.annotations)) if (columnAnnotations[key] !== value) return false;
+	}
+	if (selector.annotationPatterns !== void 0) {
+		const columnAnnotations = pcolumn.annotations || {};
+		for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {
+			const value = columnAnnotations[key];
+			if (value === void 0 || !new RegExp(pattern).test(value)) return false;
+		}
+	}
+	return true;
 }
 /**
- * Convert a predicate or array of selectors to a single predicate function
- * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,
- *                              or an array of PColumnSelectors, or a single PColumnSelector
- * @returns A function that takes a PColumnSpec and returns a boolean
- */
+* Convert a predicate or array of selectors to a single predicate function
+* @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,
+*                              or an array of PColumnSelectors, or a single PColumnSelector
+* @returns A function that takes a PColumnSpec and returns a boolean
+*/
 function selectorsToPredicate(predicateOrSelectors) {
-    if (Array.isArray(predicateOrSelectors))
-        return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));
-    else
-        return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
+	if (Array.isArray(predicateOrSelectors)) return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));
+	else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
 }
 
+//#endregion
 export { isAnchoredPColumnId, matchAxis, matchPColumn, selectorsToPredicate };
-//# sourceMappingURL=selectors.js.map
+//# sourceMappingURL=selectors.js.map

package/dist/drivers/pframe/spec/selectors.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.js","sources":["../../../../src/drivers/pframe/spec/selectors.ts"],"sourcesContent":["import { isPColumnSpec, type PObjectSpec } from \"../../../pool\";\nimport type { AxisId, AxisValueType, Domain, PColumnSpec, ValueType } from \"./spec\";\nimport { getAxisId } from \"./spec\";\n\n/**\n * Defines a pattern for matching axes within the PFrame data model.\n *\n * AxisSelector provides a flexible way to identify axes based on their\n * properties. All fields are optional, allowing for partial matching.\n * When multiple properties are specified, all must match for an axis\n * to be selected (logical AND).\n *\n * This interface is used in various selection and matching operations\n * throughout the PFrame system, such as column queries and axis lookups.\n */\nexport interface AxisSelector {\n  /**\n   * Optional value type to match against.\n   * When specified, only axes with this exact type will match.\n   * Can be a single type or an array of types to match against any of them.\n   * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.\n   */\n  type?: ValueType | ValueType[];\n\n  /**\n   * Optional name to match against.\n   * When specified, only axes with this exact name will match.\n   */\n  name?: string;\n\n  /**\n   * Optional domain key-value pairs to match against.\n   * Domains provide additional context to uniquely identify an axis beyond its name and type.\n   * When specified, an axis will match only if it contains all the key-value pairs defined here.\n   * An axis with additional domain entries not present in this selector will still match.\n   */\n  domain?: Record<string, string>;\n}\n\n/** Single axis selector */\nexport interface SingleAxisSelector {\n  /** Axis name (required) */\n  name: string;\n  /** Axis type (optional) */\n  type?: AxisValueType;\n  /** Domain requirements (optional) */\n  domain?: Domain;\n  /** Parent axes requirements (optional) */\n  parentAxes?: SingleAxisSelector[];\n}\n\n/**\n * Reference to an axis by its numerical index within the anchor column's axes array\n * Format: [anchorId, axisIndex]\n */\nexport type AnchorAxisRefByIdx = { anchor: string; idx: number };\n\n/**\n * Reference to an axis by its name within the anchor column\n * Format: [anchorId, axisName]\n */\nexport type AnchorAxisRefByName = { anchor: string; name: string };\n\n/**\n * Reference to an axis using an AxisId matcher within the anchor\n * Format: [anchorId, axisMatcher]\n */\nexport type AnchorAxisRefByMatcher = { anchor: string; id: AxisId };\n\n/**\n * Basic anchor axis reference that can be either by index or a direct AxisId\n */\nexport type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;\n\n/** Union of all possible ways to reference an axis in an anchored context  */\nexport type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;\n\n/** Reference to a domain value through an anchor */\nexport type AnchorDomainRef = { anchor: string };\n\n/**\n * Domain value that can be either a direct string value or a reference to a domain through an anchor\n * Used to establish domain context that can be resolved relative to other anchored columns\n */\nexport type ADomain = string | AnchorDomainRef;\n/**\n * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor\n * Allows referring to axes in a way that can be resolved in different contexts\n */\nexport type AAxisSelector = AxisSelector | AnchorAxisRef;\n\n/**\n * Match resolution strategy for PColumns\n * Specifies how to handle when multiple columns match the criteria\n * (default is \"expectSingle\")\n */\nexport type AnchoredColumnMatchStrategy = \"expectSingle\" | \"expectMultiple\" | \"takeFirst\";\n\n/**\n * Matcher for PColumns in an anchored context\n * Supports partial matching on axes, allowing for flexible column discovery\n */\nexport interface AnchoredPColumnSelector {\n  /** Optional name of the column to match; can't be used together with namePattern */\n  name?: string;\n  /** Optional regexp pattern for column name matching; can't be used together with name */\n  namePattern?: string;\n  /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */\n  type?: ValueType | ValueType[];\n  /** If specified, the domain values must be anchored to this anchor */\n  domainAnchor?: string;\n  /** Optional domain values to match, can include anchored references, if domainAnchor is specified,\n   * interpreted as additional domains to domain from the anchor */\n  domain?: Record<string, ADomain>;\n  /** Optional axes to match, can include anchored references */\n  axes?: AAxisSelector[];\n  /** When true, allows matching if only a subset of axes match */\n  partialAxesMatch?: boolean;\n  /** Optional annotations to match with exact values */\n  annotations?: Record<string, string>;\n  /** Optional annotation patterns to match with regex patterns */\n  annotationPatterns?: Record<string, string>;\n  /** Match resolution strategy, default is \"expectSingle\" */\n  matchStrategy?: AnchoredColumnMatchStrategy;\n}\n\n/**\n * Matcher for PColumns in a non-anchored context\n */\nexport interface PColumnSelector extends AnchoredPColumnSelector {\n  domainAnchor?: never;\n  domain?: Record<string, string>;\n  axes?: AxisSelector[];\n}\n\n/**\n * Strict identifier for PColumns in an anchored context\n * Unlike APColumnMatcher, this requires exact matches on domain and axes\n */\nexport interface AnchoredPColumnId extends AnchoredPColumnSelector {\n  /** Name is required for exact column identification */\n  name: string;\n  /** No namePattern in ID */\n  namePattern?: never;\n  /** Type is not used in exact column identification */\n  type?: never;\n  /** Full axes specification using only basic references */\n  axes: AnchorAxisIdOrRefBasic[];\n  /** Partial axes matching is not allowed for exact identification */\n  partialAxesMatch?: never;\n  /** Annotations are not used in exact column identification */\n  annotations?: never;\n  /** Annotation patterns are not used in exact column identification */\n  annotationPatterns?: never;\n  /** \"Id\" implies single match strategy */\n  matchStrategy?: never;\n}\n\n/**\n * Checks if a given value is an anchored column identifier\n * @param id - The value to check\n * @returns True if the value is an anchored column identifier, false otherwise\n */\nexport function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnId {\n  // basic check, can be extended if needed\n  return typeof id === \"object\" && id !== null && \"name\" in id && \"axes\" in id;\n}\n\n/**\n * Determines if an axis ID matches an axis selector.\n *\n * @param selector - The selector with criteria to match against\n * @param axis - The AxisId to check against the selector\n * @returns true if the AxisId matches all specified criteria in the selector, false otherwise\n */\nexport function matchAxis(selector: AxisSelector, axis: AxisId): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && selector.name !== axis.name) return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(axis.type)) return false;\n    } else if (selector.type !== axis.type) {\n      return false;\n    }\n  }\n\n  // Match domain if specified - using existing logic from matchAxisId\n  if (selector.domain !== undefined) {\n    const axisDomain = axis.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (axisDomain[key] !== value) return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a given PColumnSpec matches a selector.\n *\n * @param pcolumn - The PColumnSpec to check against the selector\n * @param selector - The selector criteria to match against\n * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise\n */\nexport function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && pcolumn.name !== selector.name) return false;\n\n  // Match name pattern if specified\n  if (selector.namePattern !== undefined && !new RegExp(selector.namePattern).test(pcolumn.name))\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(pcolumn.valueType)) return false;\n    } else if (selector.type !== pcolumn.valueType) {\n      return false;\n    }\n  }\n\n  // Match domain if specified\n  if (selector.domain !== undefined) {\n    const columnDomain = pcolumn.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (columnDomain[key] !== value) return false;\n  }\n\n  // Match axes if specified\n  if (selector.axes !== undefined) {\n    const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);\n\n    if (selector.partialAxesMatch) {\n      // For partial matching, all selector axes must match at least one column axis\n      for (const selectorAxis of selector.axes)\n        if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis))) return false;\n    } else {\n      // For exact matching, column must have the same number of axes and all must match\n      if (pcolumnAxes.length !== selector.axes.length) return false;\n\n      // Each selector axis must match a corresponding column axis\n      for (let i = 0; i < selector.axes.length; i++)\n        if (!matchAxis(selector.axes[i], pcolumnAxes[i])) return false;\n    }\n  }\n\n  // Match annotations if specified\n  if (selector.annotations !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, value] of Object.entries(selector.annotations))\n      if (columnAnnotations[key] !== value) return false;\n  }\n\n  // Match annotation patterns if specified\n  if (selector.annotationPatterns !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {\n      const value = columnAnnotations[key];\n      if (value === undefined || !new RegExp(pattern).test(value)) return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Convert a predicate or array of selectors to a single predicate function\n * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,\n *                              or an array of PColumnSelectors, or a single PColumnSelector\n * @returns A function that takes a PColumnSpec and returns a boolean\n */\nexport function selectorsToPredicate(\n  predicateOrSelectors: PColumnSelector | PColumnSelector[],\n): (spec: PObjectSpec) => boolean {\n  if (Array.isArray(predicateOrSelectors))\n    return (spec) =>\n      predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));\n  else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"selectors.js","names":[],"sources":["../../../../src/drivers/pframe/spec/selectors.ts"],"sourcesContent":["import { isPColumnSpec, type PObjectSpec } from \"../../../pool\";\nimport type { AxisId, AxisValueType, Domain, PColumnSpec, ValueType } from \"./spec\";\nimport { getAxisId } from \"./spec\";\n\n/**\n * Defines a pattern for matching axes within the PFrame data model.\n *\n * AxisSelector provides a flexible way to identify axes based on their\n * properties. All fields are optional, allowing for partial matching.\n * When multiple properties are specified, all must match for an axis\n * to be selected (logical AND).\n *\n * This interface is used in various selection and matching operations\n * throughout the PFrame system, such as column queries and axis lookups.\n */\nexport interface AxisSelector {\n  /**\n   * Optional value type to match against.\n   * When specified, only axes with this exact type will match.\n   * Can be a single type or an array of types to match against any of them.\n   * Valid types include: 'Int', 'Long', 'Float', 'Double', 'String', 'Bytes'.\n   */\n  type?: ValueType | ValueType[];\n\n  /**\n   * Optional name to match against.\n   * When specified, only axes with this exact name will match.\n   */\n  name?: string;\n\n  /**\n   * Optional domain key-value pairs to match against.\n   * Domains provide additional context to uniquely identify an axis beyond its name and type.\n   * When specified, an axis will match only if it contains all the key-value pairs defined here.\n   * An axis with additional domain entries not present in this selector will still match.\n   */\n  domain?: Record<string, string>;\n}\n\n/** Single axis selector */\nexport interface SingleAxisSelector {\n  /** Axis name (required) */\n  name: string;\n  /** Axis type (optional) */\n  type?: AxisValueType;\n  /** Domain requirements (optional) */\n  domain?: Domain;\n  /** Parent axes requirements (optional) */\n  parentAxes?: SingleAxisSelector[];\n}\n\n/**\n * Reference to an axis by its numerical index within the anchor column's axes array\n * Format: [anchorId, axisIndex]\n */\nexport type AnchorAxisRefByIdx = { anchor: string; idx: number };\n\n/**\n * Reference to an axis by its name within the anchor column\n * Format: [anchorId, axisName]\n */\nexport type AnchorAxisRefByName = { anchor: string; name: string };\n\n/**\n * Reference to an axis using an AxisId matcher within the anchor\n * Format: [anchorId, axisMatcher]\n */\nexport type AnchorAxisRefByMatcher = { anchor: string; id: AxisId };\n\n/**\n * Basic anchor axis reference that can be either by index or a direct AxisId\n */\nexport type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;\n\n/** Union of all possible ways to reference an axis in an anchored context  */\nexport type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;\n\n/** Reference to a domain value through an anchor */\nexport type AnchorDomainRef = { anchor: string };\n\n/**\n * Domain value that can be either a direct string value or a reference to a domain through an anchor\n * Used to establish domain context that can be resolved relative to other anchored columns\n */\nexport type ADomain = string | AnchorDomainRef;\n/**\n * Axis identifier that can be either a direct AxisId or a reference to an axis through an anchor\n * Allows referring to axes in a way that can be resolved in different contexts\n */\nexport type AAxisSelector = AxisSelector | AnchorAxisRef;\n\n/**\n * Match resolution strategy for PColumns\n * Specifies how to handle when multiple columns match the criteria\n * (default is \"expectSingle\")\n */\nexport type AnchoredColumnMatchStrategy = \"expectSingle\" | \"expectMultiple\" | \"takeFirst\";\n\n/**\n * Matcher for PColumns in an anchored context\n * Supports partial matching on axes, allowing for flexible column discovery\n */\nexport interface AnchoredPColumnSelector {\n  /** Optional name of the column to match; can't be used together with namePattern */\n  name?: string;\n  /** Optional regexp pattern for column name matching; can't be used together with name */\n  namePattern?: string;\n  /** Optional value type to match. If an array is provided, matches if the column's type is any of the specified types */\n  type?: ValueType | ValueType[];\n  /** If specified, the domain values must be anchored to this anchor */\n  domainAnchor?: string;\n  /** Optional domain values to match, can include anchored references, if domainAnchor is specified,\n   * interpreted as additional domains to domain from the anchor */\n  domain?: Record<string, ADomain>;\n  /** Optional axes to match, can include anchored references */\n  axes?: AAxisSelector[];\n  /** When true, allows matching if only a subset of axes match */\n  partialAxesMatch?: boolean;\n  /** Optional annotations to match with exact values */\n  annotations?: Record<string, string>;\n  /** Optional annotation patterns to match with regex patterns */\n  annotationPatterns?: Record<string, string>;\n  /** Match resolution strategy, default is \"expectSingle\" */\n  matchStrategy?: AnchoredColumnMatchStrategy;\n}\n\n/**\n * Matcher for PColumns in a non-anchored context\n */\nexport interface PColumnSelector extends AnchoredPColumnSelector {\n  domainAnchor?: never;\n  domain?: Record<string, string>;\n  axes?: AxisSelector[];\n}\n\n/**\n * Strict identifier for PColumns in an anchored context\n * Unlike APColumnMatcher, this requires exact matches on domain and axes\n */\nexport interface AnchoredPColumnId extends AnchoredPColumnSelector {\n  /** Name is required for exact column identification */\n  name: string;\n  /** No namePattern in ID */\n  namePattern?: never;\n  /** Type is not used in exact column identification */\n  type?: never;\n  /** Full axes specification using only basic references */\n  axes: AnchorAxisIdOrRefBasic[];\n  /** Partial axes matching is not allowed for exact identification */\n  partialAxesMatch?: never;\n  /** Annotations are not used in exact column identification */\n  annotations?: never;\n  /** Annotation patterns are not used in exact column identification */\n  annotationPatterns?: never;\n  /** \"Id\" implies single match strategy */\n  matchStrategy?: never;\n}\n\n/**\n * Checks if a given value is an anchored column identifier\n * @param id - The value to check\n * @returns True if the value is an anchored column identifier, false otherwise\n */\nexport function isAnchoredPColumnId(id: unknown): id is AnchoredPColumnId {\n  // basic check, can be extended if needed\n  return typeof id === \"object\" && id !== null && \"name\" in id && \"axes\" in id;\n}\n\n/**\n * Determines if an axis ID matches an axis selector.\n *\n * @param selector - The selector with criteria to match against\n * @param axis - The AxisId to check against the selector\n * @returns true if the AxisId matches all specified criteria in the selector, false otherwise\n */\nexport function matchAxis(selector: AxisSelector, axis: AxisId): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && selector.name !== axis.name) return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(axis.type)) return false;\n    } else if (selector.type !== axis.type) {\n      return false;\n    }\n  }\n\n  // Match domain if specified - using existing logic from matchAxisId\n  if (selector.domain !== undefined) {\n    const axisDomain = axis.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (axisDomain[key] !== value) return false;\n  }\n\n  return true;\n}\n\n/**\n * Determines if a given PColumnSpec matches a selector.\n *\n * @param pcolumn - The PColumnSpec to check against the selector\n * @param selector - The selector criteria to match against\n * @returns true if the PColumnSpec matches all criteria in the selector, false otherwise\n */\nexport function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean {\n  // Match name if specified\n  if (selector.name !== undefined && pcolumn.name !== selector.name) return false;\n\n  // Match name pattern if specified\n  if (selector.namePattern !== undefined && !new RegExp(selector.namePattern).test(pcolumn.name))\n    return false;\n\n  // Match type if specified\n  if (selector.type !== undefined) {\n    if (Array.isArray(selector.type)) {\n      if (!selector.type.includes(pcolumn.valueType)) return false;\n    } else if (selector.type !== pcolumn.valueType) {\n      return false;\n    }\n  }\n\n  // Match domain if specified\n  if (selector.domain !== undefined) {\n    const columnDomain = pcolumn.domain || {};\n    for (const [key, value] of Object.entries(selector.domain))\n      if (columnDomain[key] !== value) return false;\n  }\n\n  // Match axes if specified\n  if (selector.axes !== undefined) {\n    const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);\n\n    if (selector.partialAxesMatch) {\n      // For partial matching, all selector axes must match at least one column axis\n      for (const selectorAxis of selector.axes)\n        if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis))) return false;\n    } else {\n      // For exact matching, column must have the same number of axes and all must match\n      if (pcolumnAxes.length !== selector.axes.length) return false;\n\n      // Each selector axis must match a corresponding column axis\n      for (let i = 0; i < selector.axes.length; i++)\n        if (!matchAxis(selector.axes[i], pcolumnAxes[i])) return false;\n    }\n  }\n\n  // Match annotations if specified\n  if (selector.annotations !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, value] of Object.entries(selector.annotations))\n      if (columnAnnotations[key] !== value) return false;\n  }\n\n  // Match annotation patterns if specified\n  if (selector.annotationPatterns !== undefined) {\n    const columnAnnotations = pcolumn.annotations || {};\n    for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {\n      const value = columnAnnotations[key];\n      if (value === undefined || !new RegExp(pattern).test(value)) return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Convert a predicate or array of selectors to a single predicate function\n * @param predicateOrSelectors - Either a function that takes a PColumnSpec and returns a boolean,\n *                              or an array of PColumnSelectors, or a single PColumnSelector\n * @returns A function that takes a PColumnSpec and returns a boolean\n */\nexport function selectorsToPredicate(\n  predicateOrSelectors: PColumnSelector | PColumnSelector[],\n): (spec: PObjectSpec) => boolean {\n  if (Array.isArray(predicateOrSelectors))\n    return (spec) =>\n      predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));\n  else return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);\n}\n"],"mappings":";;;;;;;;;AAmKA,SAAgB,oBAAoB,IAAsC;AAExE,QAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,UAAU,MAAM,UAAU;;;;;;;;;AAU5E,SAAgB,UAAU,UAAwB,MAAuB;AAEvE,KAAI,SAAS,SAAS,UAAa,SAAS,SAAS,KAAK,KAAM,QAAO;AAGvE,KAAI,SAAS,SAAS,QACpB;MAAI,MAAM,QAAQ,SAAS,KAAK,EAC9B;OAAI,CAAC,SAAS,KAAK,SAAS,KAAK,KAAK,CAAE,QAAO;aACtC,SAAS,SAAS,KAAK,KAChC,QAAO;;AAKX,KAAI,SAAS,WAAW,QAAW;EACjC,MAAM,aAAa,KAAK,UAAU,EAAE;AACpC,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,OAAO,CACxD,KAAI,WAAW,SAAS,MAAO,QAAO;;AAG1C,QAAO;;;;;;;;;AAUT,SAAgB,aAAa,SAAsB,UAAoC;AAErF,KAAI,SAAS,SAAS,UAAa,QAAQ,SAAS,SAAS,KAAM,QAAO;AAG1E,KAAI,SAAS,gBAAgB,UAAa,CAAC,IAAI,OAAO,SAAS,YAAY,CAAC,KAAK,QAAQ,KAAK,CAC5F,QAAO;AAGT,KAAI,SAAS,SAAS,QACpB;MAAI,MAAM,QAAQ,SAAS,KAAK,EAC9B;OAAI,CAAC,SAAS,KAAK,SAAS,QAAQ,UAAU,CAAE,QAAO;aAC9C,SAAS,SAAS,QAAQ,UACnC,QAAO;;AAKX,KAAI,SAAS,WAAW,QAAW;EACjC,MAAM,eAAe,QAAQ,UAAU,EAAE;AACzC,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,OAAO,CACxD,KAAI,aAAa,SAAS,MAAO,QAAO;;AAI5C,KAAI,SAAS,SAAS,QAAW;EAC/B,MAAM,cAAc,QAAQ,SAAS,IAAI,UAAU;AAEnD,MAAI,SAAS,kBAEX;QAAK,MAAM,gBAAgB,SAAS,KAClC,KAAI,CAAC,YAAY,MAAM,eAAe,UAAU,cAAc,WAAW,CAAC,CAAE,QAAO;SAChF;AAEL,OAAI,YAAY,WAAW,SAAS,KAAK,OAAQ,QAAO;AAGxD,QAAK,IAAI,IAAI,GAAG,IAAI,SAAS,KAAK,QAAQ,IACxC,KAAI,CAAC,UAAU,SAAS,KAAK,IAAI,YAAY,GAAG,CAAE,QAAO;;;AAK/D,KAAI,SAAS,gBAAgB,QAAW;EACtC,MAAM,oBAAoB,QAAQ,eAAe,EAAE;AACnD,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,YAAY,CAC7D,KAAI,kBAAkB,SAAS,MAAO,QAAO;;AAIjD,KAAI,SAAS,uBAAuB,QAAW;EAC7C,MAAM,oBAAoB,QAAQ,eAAe,EAAE;AACnD,OAAK,MAAM,CAAC,KAAK,YAAY,OAAO,QAAQ,SAAS,mBAAmB,EAAE;GACxE,MAAM,QAAQ,kBAAkB;AAChC,OAAI,UAAU,UAAa,CAAC,IAAI,OAAO,QAAQ,CAAC,KAAK,MAAM,CAAE,QAAO;;;AAIxE,QAAO;;;;;;;;AAST,SAAgB,qBACd,sBACgC;AAChC,KAAI,MAAM,QAAQ,qBAAqB,CACrC,SAAQ,SACN,qBAAqB,MAAM,aAAa,cAAc,KAAK,IAAI,aAAa,MAAM,SAAS,CAAC;KAC3F,SAAQ,SAAS,cAAc,KAAK,IAAI,aAAa,MAAM,qBAAqB"}