@milaboratories/pl-model-common 1.10.6 → 1.11.1

package/src/drivers/pframe/spec/anchored_id.ts

@@ -0,0 +1,223 @@
+import canonicalize from 'canonicalize';
+import type { AxisId, PColumnSpec } from './spec';
+import { getAxisId, matchAxisId } from './spec';
+import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, APColumnId, APColumnSelector, AxisSelector, PColumnSelector } from './selectors';
+import type { Branded } from '../../../branding';
+
+//
+// Helper functions
+//
+
+function axisKey(axis: AxisId): string {
+  return canonicalize(getAxisId(axis))!;
+}
+
+function domainKey(key: string, value: string): string {
+  return JSON.stringify([key, value]);
+}
+
+//
+// Branded types
+//
+
+/** Canonicalized string representation of an anchored column identifier, either anchored or absolute. */
+export type CanonicalPColumnId = Branded<string, 'CanonicalPColumnId'>;
+
+/**
+ * Context for resolving and generating anchored references to columns and axes
+ * Maintains maps of known domain values and axes that can be referenced by anchors
+ */
+export class AnchorIdDeriver {
+  private readonly domains = new Map<string, string>();
+  private readonly axes = new Map<string, AnchorAxisRefByIdx>();
+  /**
+   * Domain packs are used to group domain keys that can be anchored to the same anchor
+   * This is used to optimize the lookup of domain anchors
+   */
+  private readonly domainPacks: string[][] = [];
+  /**
+   * Maps domain packs to anchors
+   */
+  private readonly domainPackToAnchor = new Map<string, string>();
+
+  /**
+   * Creates a new anchor context from a set of anchor column specifications
+   * @param anchors Record of anchor column specifications indexed by anchor ID
+   */
+  constructor(private readonly anchors: Record<string, PColumnSpec>) {
+    const anchorEntries = Object.entries(anchors);
+    anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [anchorId, spec] of anchorEntries) {
+      for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {
+        const axis = spec.axesSpec[axisIdx];
+        const key = axisKey(axis);
+        this.axes.set(key, { anchor: anchorId, idx: axisIdx });
+      }
+      if (spec.domain !== undefined) {
+        const domainEntries = Object.entries(spec.domain);
+        domainEntries.sort((a, b) => a[0].localeCompare(b[0]));
+
+        this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);
+        this.domainPacks.push(domainEntries.map(([dKey]) => dKey));
+
+        for (const [dKey, dValue] of domainEntries) {
+          const key = domainKey(dKey, dValue);
+          this.domains.set(key, anchorId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Derives an anchored column identifier from a column specification
+   * Replaces domain values and axes with anchored references when possible
+   * @param spec Column specification to anchor
+   * @returns An anchored column identifier that can be used to identify columns similar to the input specification
+   */
+  derive(spec: PColumnSpec): APColumnId {
+    const result: APColumnId = {
+      name: spec.name,
+      axes: [],
+    };
+
+    let skipDomains: Set<string> | undefined = undefined;
+    if (spec.domain !== undefined) {
+      outer:
+      for (const domainPack of this.domainPacks) {
+        const dAnchor: string[][] = [];
+        for (const domainKey of domainPack) {
+          const dValue = spec.domain[domainKey];
+          if (dValue !== undefined)
+            dAnchor.push([domainKey, dValue]);
+          else
+            break outer;
+        }
+        const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));
+        if (domainAnchor !== undefined) {
+          result.domainAnchor = domainAnchor;
+          skipDomains = new Set(domainPack);
+          break;
+        }
+      }
+    }
+
+    for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {
+      if (skipDomains !== undefined && skipDomains.has(dKey))
+        continue;
+      const key = domainKey(dKey, dValue);
+      const anchorId = this.domains.get(key);
+      result.domain ??= {};
+      result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;
+    }
+
+    result.axes = spec.axesSpec.map((axis) => {
+      const key = axisKey(axis);
+      const anchorAxisRef = this.axes.get(key);
+      return anchorAxisRef ?? axis;
+    });
+
+    return result;
+  }
+
+  /**
+   * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column
+   * @param spec Column specification to anchor
+   * @returns A canonicalized string representation of the anchored column identifier
+   */
+  deriveCanonical(spec: PColumnSpec): CanonicalPColumnId {
+    const aId = this.derive(spec);
+    return canonicalize(aId)! as CanonicalPColumnId;
+  }
+}
+
+/**
+ * Resolves anchored references in a column matcher to create a non-anchored matcher
+ *
+ * @param anchors - Record of anchor column specifications indexed by anchor ID
+ * @param matcher - An anchored column matcher containing references that need to be resolved
+ * @returns A non-anchored column matcher with all references resolved to actual values
+ */
+export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: APColumnSelector): PColumnSelector {
+  const result = { ...matcher };
+
+  if (result.domainAnchor !== undefined) {
+    const anchorSpec = anchors[result.domainAnchor];
+    if (!anchorSpec)
+      throw new Error(`Anchor "${result.domainAnchor}" not found`);
+
+    const anchorDomains = anchorSpec.domain || {};
+    result.domain = { ...anchorDomains, ...result.domain };
+    delete result.domainAnchor;
+  }
+
+  if (result.domain) {
+    const resolvedDomain: Record<string, string> = {};
+    for (const [key, value] of Object.entries(result.domain)) {
+      if (typeof value === 'string') {
+        resolvedDomain[key] = value;
+      } else {
+        // It's an AnchorDomainRef
+        const anchorSpec = anchors[value.anchor];
+        if (!anchorSpec)
+          throw new Error(`Anchor "${value.anchor}" not found for domain key "${key}"`);
+
+        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined)
+          throw new Error(`Domain key "${key}" not found in anchor "${value.anchor}"`);
+
+        resolvedDomain[key] = anchorSpec.domain[key];
+      }
+    }
+    result.domain = resolvedDomain;
+  }
+
+  if (result.axes)
+    result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));
+
+  return result as PColumnSelector;
+}
+
+/**
+ * Resolves an anchored axis reference to a concrete AxisId
+ */
+function resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAxisSelector): AxisSelector {
+  if (!isAnchorAxisRef(axisRef))
+    return axisRef;
+
+  // It's an anchored reference
+  const anchorId = axisRef.anchor;
+  const anchorSpec = anchors[anchorId];
+  if (!anchorSpec)
+    throw new Error(`Anchor "${anchorId}" not found for axis reference`);
+
+  if ('idx' in axisRef) {
+    // AnchorAxisRefByIdx
+    if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)
+      throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor "${anchorId}"`);
+    return anchorSpec.axesSpec[axisRef.idx];
+  } else if ('name' in axisRef) {
+    // AnchorAxisRefByName
+    const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);
+    if (matches.length > 1)
+      throw new Error(`Multiple axes with name "${axisRef.name}" found in anchor "${anchorId}"`);
+    if (matches.length === 0)
+      throw new Error(`Axis with name "${axisRef.name}" not found in anchor "${anchorId}"`);
+    return matches[0];
+  } else if ('id' in axisRef) {
+    // AnchorAxisRefByMatcher
+    const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));
+    if (matches.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${anchorId}"`);
+    if (matches.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${anchorId}"`);
+    return matches[0];
+  }
+
+  throw new Error(`Unsupported axis reference type`);
+}
+
+/**
+ * Type guard to check if a value is an anchored axis reference
+ */
+function isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {
+  return typeof value === 'object' && 'anchor' in value;
+}

package/src/drivers/pframe/spec/index.ts

@@ -0,0 +1,3 @@
+export * from './anchored_id';
+export * from './spec';
+export * from './selectors';

package/src/drivers/pframe/spec/selectors.test.ts

@@ -0,0 +1,209 @@
+import { describe, test, expect } from 'vitest';
+import { matchPColumn, matchAxis } from './selectors';
+import type { PColumnSpec, AxisSpec, AxisId } from './spec';
+
+describe('matchPColumn', () => {
+  // Test data
+  const testColumn: PColumnSpec = {
+    kind: 'PColumn',
+    name: 'testColumn',
+    valueType: 'Int',
+    domain: {
+      domain1: 'value1',
+      domain2: 'value2',
+    },
+    axesSpec: [
+      {
+        name: 'x',
+        type: 'String',
+        domain: {
+          key: 'xDomain',
+        },
+      } as AxisSpec,
+      {
+        name: 'y',
+        type: 'String',
+        domain: {
+          key: 'yDomain',
+        },
+      } as AxisSpec,
+    ],
+    annotations: {
+      anno1: 'value1',
+      anno2: 'value2',
+    },
+  };
+
+  test('matches on name', () => {
+    expect(matchPColumn(testColumn, { name: 'testColumn' })).toBe(true);
+    expect(matchPColumn(testColumn, { name: 'wrongName' })).toBe(false);
+  });
+
+  test('matches on name pattern', () => {
+    expect(matchPColumn(testColumn, { namePattern: 'test.*' })).toBe(true);
+    expect(matchPColumn(testColumn, { namePattern: 'wrong.*' })).toBe(false);
+  });
+
+  test('matches on value type', () => {
+    expect(matchPColumn(testColumn, { type: 'Int' })).toBe(true);
+    expect(matchPColumn(testColumn, { type: 'String' })).toBe(false);
+    expect(matchPColumn(testColumn, { type: ['Int', 'Double'] })).toBe(true);
+    expect(matchPColumn(testColumn, { type: ['String', 'Float'] })).toBe(false);
+  });
+
+  test('matches on domain', () => {
+    expect(matchPColumn(testColumn, { domain: { domain1: 'value1' } })).toBe(true);
+    expect(matchPColumn(testColumn, { domain: { domain1: 'wrongValue' } })).toBe(false);
+    expect(matchPColumn(testColumn, { domain: { nonExistentDomain: 'value' } })).toBe(false);
+  });
+
+  test('matches on axes', () => {
+    expect(matchPColumn(testColumn, {
+      axes: [
+        {
+          name: 'x',
+          type: 'String',
+          domain: {
+            key: 'xDomain',
+          },
+        },
+        {
+          name: 'y',
+          type: 'String',
+          domain: {
+            key: 'yDomain',
+          },
+        },
+      ],
+    })).toBe(true);
+
+    // Test partial match
+    expect(matchPColumn(testColumn, {
+      axes: [{
+        name: 'x',
+        domain: {
+          key: 'xDomain',
+        },
+      }],
+      partialAxesMatch: true,
+    })).toBe(true);
+
+    // Test failed match (wrong axis)
+    expect(matchPColumn(testColumn, {
+      axes: [{
+        name: 'z',
+        type: 'String',
+        domain: {
+          key: 'zDomain',
+        },
+      }],
+      partialAxesMatch: true,
+    })).toBe(false);
+
+    // Test failed match (count mismatch with exact matching)
+    expect(matchPColumn(testColumn, {
+      axes: [{
+        name: 'x',
+        type: 'String',
+        domain: {
+          key: 'xDomain',
+        },
+      }],
+    })).toBe(false);
+  });
+
+  test('matches on annotations', () => {
+    expect(matchPColumn(testColumn, { annotations: { anno1: 'value1' } })).toBe(true);
+    expect(matchPColumn(testColumn, { annotations: { anno1: 'wrongValue' } })).toBe(false);
+    expect(matchPColumn(testColumn, { annotations: { nonExistentAnno: 'value' } })).toBe(false);
+  });
+
+  test('matches on annotation patterns', () => {
+    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: 'value\\d' } })).toBe(true);
+    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: 'wrong.*' } })).toBe(false);
+    expect(matchPColumn(testColumn, { annotationPatterns: { nonExistentAnno: '.*' } })).toBe(false);
+  });
+
+  test('matches on multiple criteria', () => {
+    expect(matchPColumn(testColumn, {
+      name: 'testColumn',
+      type: 'Int',
+      domain: { domain1: 'value1' },
+      annotations: { anno1: 'value1' },
+    })).toBe(true);
+
+    expect(matchPColumn(testColumn, {
+      name: 'testColumn',
+      type: 'Int',
+      domain: { domain1: 'wrongValue' }, // This will fail
+      annotations: { anno1: 'value1' },
+    })).toBe(false);
+  });
+});
+
+describe('matchAxis', () => {
+  // Test data
+  const testAxis: AxisId = {
+    name: 'testAxis',
+    type: 'String',
+    domain: {
+      key1: 'value1',
+      key2: 'value2',
+    },
+  };
+
+  test('matches on axis name', () => {
+    expect(matchAxis({ name: 'testAxis' }, testAxis)).toBe(true);
+    expect(matchAxis({ name: 'wrongAxis' }, testAxis)).toBe(false);
+  });
+
+  test('matches on axis type', () => {
+    expect(matchAxis({ type: 'String' }, testAxis)).toBe(true);
+    expect(matchAxis({ type: 'Int' }, testAxis)).toBe(false);
+    expect(matchAxis({ type: ['String', 'Int'] }, testAxis)).toBe(true);
+    expect(matchAxis({ type: ['Int', 'Double'] }, testAxis)).toBe(false);
+  });
+
+  test('matches on axis domain', () => {
+    expect(matchAxis({ domain: { key1: 'value1' } }, testAxis)).toBe(true);
+    expect(matchAxis({ domain: { key1: 'wrongValue' } }, testAxis)).toBe(false);
+    expect(matchAxis({ domain: { nonExistentKey: 'value' } }, testAxis)).toBe(false);
+  });
+
+  test('matches on multiple axis criteria', () => {
+    expect(matchAxis(
+      {
+        name: 'testAxis',
+        type: 'String',
+        domain: { key1: 'value1' },
+      },
+      testAxis,
+    )).toBe(true);
+
+    expect(matchAxis(
+      {
+        name: 'testAxis',
+        type: 'String',
+        domain: { key1: 'wrongValue' }, // This will fail
+      },
+      testAxis,
+    )).toBe(false);
+
+    expect(matchAxis(
+      {
+        name: 'testAxis',
+        type: 'Int', // This will fail
+        domain: { key1: 'value1' },
+      },
+      testAxis,
+    )).toBe(false);
+  });
+
+  test('matches with empty domain criteria', () => {
+    expect(matchAxis({ domain: {} }, testAxis)).toBe(true);
+  });
+
+  test('matches with partial domain criteria', () => {
+    expect(matchAxis({ domain: { key1: 'value1' } }, testAxis)).toBe(true);
+  });
+});

package/src/drivers/pframe/spec/selectors.ts

@@ -0,0 +1,267 @@
+import { isPColumnSpec, type PObjectSpec } from '../../../pool';
+import type { AxisId, PColumnSpec, ValueType } from './spec';
+import { getAxisId, matchAxisId } from './spec';
+
+/**
+ * Defines a pattern for matching axes within the PFrame data model.
+ *
+ * AxisSelector provides a flexible way to identify axes based on their
+ * properties. All fields are optional, allowing for partial matching.
+ * When multiple properties are specified, all must match for an axis
+ * to be selected (logical AND).
+ *
+ * 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>;
+}
+
+/**
+ * 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 };
+
+/**
+ * Reference to an axis by its name within the anchor column
+ * Format: [anchorId, axisName]
+ */
+export 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 };
+
+/**
+ * Basic anchor axis reference that can be either by index or a direct AxisId
+ */
+export type AnchorAxisIdOrRefBasic = AnchorAxisRefByIdx | AxisId;
+
+/** Union of all possible ways to reference an axis in an anchored context  */
+export type AnchorAxisRef = AnchorAxisRefByIdx | AnchorAxisRefByName | AnchorAxisRefByMatcher;
+
+/** Reference to a domain value through an anchor */
+export 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;
+/**
+ * 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;
+
+/**
+ * Match resolution strategy for PColumns
+ * Specifies how to handle when multiple columns match the criteria
+ * (default is "expectSingle")
+ */
+export type AnchoredColumnMatchStrategy = 'expectSingle' | 'expectMultiple' | 'takeFirst';
+
+/**
+ * Matcher for PColumns in an anchored context
+ * Supports partial matching on axes, allowing for flexible column discovery
+ */
+export interface APColumnSelector {
+  /** 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 APColumnSelector {
+  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 APColumnId extends APColumnSelector {
+  /** 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;
+}
+
+/**
+ * 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
+ */
+export function matchAxis(selector: AxisSelector, axis: AxisId): boolean {
+  // 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;
+}
+
+/**
+ * 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
+ */
+export function matchPColumn(pcolumn: PColumnSpec, selector: PColumnSelector): boolean {
+  // 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;
+}
+
+/**
+ * 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 function selectorsToPredicate(predicateOrSelectors: PColumnSelector | PColumnSelector[]): ((spec: PObjectSpec) => boolean) {
+  if (Array.isArray(predicateOrSelectors))
+    return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));
+  else
+    return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
+}