@milaboratories/pl-model-common 1.25.0 → 1.25.2

package/dist/pool/entry.d.ts

@@ -1,16 +1,16 @@
-import type { PlRef } from "../ref";
+import { PlRef } from "../ref.js";
+
+//#region src/pool/entry.d.ts
 /** Result pool entry */
-export type ResultPoolEntry<O> = {
-    /** Reference that can be passed to args to import the object in workflow */
-    readonly ref: PlRef;
-    /** Object. Normally spec or PObject. */
-    readonly obj: O;
+type ResultPoolEntry<O> = {
+  /** Reference that can be passed to args to import the object in workflow */readonly ref: PlRef; /** Object. Normally spec or PObject. */
+  readonly obj: O;
 };
 /** Collection of results from the result pool */
-export type ResultCollection<O> = {
-    /** List of results from the pool */
-    readonly entries: ResultPoolEntry<O>[];
-    /** False means that current collection is not fully loaded due to some computations still taking place */
-    readonly isComplete: boolean;
+type ResultCollection<O> = {
+  /** List of results from the pool */readonly entries: ResultPoolEntry<O>[]; /** False means that current collection is not fully loaded due to some computations still taking place */
+  readonly isComplete: boolean;
 };
+//#endregion
+export { ResultCollection, ResultPoolEntry };
 //# sourceMappingURL=entry.d.ts.map

package/dist/pool/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./entry";
-export * from "./spec";
-export * from "./query";
-//# sourceMappingURL=index.d.ts.map
+import { ResultCollection, ResultPoolEntry } from "./entry.js";
+import { PObject, PObjectId, PObjectSpec, ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, mapPObjectData } from "./spec.js";
+import { PSpecPredicate, executePSpecPredicate } from "./query.js";

package/dist/pool/query.cjs

@@ -1,49 +1,27 @@
-'use strict';
-
-var spec = require('./spec.cjs');
+const require_spec = require('./spec.cjs');
 
+//#region src/pool/query.ts
 function assertNever(x) {
-    throw new Error("Unexpected object: " + x); // This is ok, because this is a possible runtime error
+	throw new Error("Unexpected object: " + x);
 }
-function executePSpecPredicate(predicate, spec$1) {
-    switch (predicate.type) {
-        case "and":
-            for (const operator of predicate.operands)
-                if (!executePSpecPredicate(operator, spec$1))
-                    return false;
-            return true;
-        case "or":
-            for (const operator of predicate.operands)
-                if (executePSpecPredicate(operator, spec$1))
-                    return true;
-            return false;
-        case "not":
-            return !executePSpecPredicate(predicate.operand, spec$1);
-        case "name":
-            return spec.isPColumnSpec(spec$1) && spec$1.name === predicate.name;
-        case "name_pattern":
-            return spec.isPColumnSpec(spec$1) && Boolean(spec$1.name.match(predicate.pattern));
-        case "annotation":
-            return (spec.isPColumnSpec(spec$1) &&
-                spec$1.annotations !== undefined &&
-                spec$1.annotations[predicate.annotation] === predicate.value);
-        case "annotation_pattern":
-            return (spec.isPColumnSpec(spec$1) &&
-                spec$1.annotations !== undefined &&
-                spec$1.annotations[predicate.annotation] !== undefined &&
-                Boolean(spec$1.annotations[predicate.annotation].match(predicate.pattern)));
-        case "has_axes":
-            return (spec.isPColumnSpec(spec$1) &&
-                predicate.axes.every((matcher) => spec$1.axesSpec.some((axisSpec) => (matcher.type === undefined || matcher.type === axisSpec.type) &&
-                    (matcher.name === undefined || matcher.name === axisSpec.name) &&
-                    (matcher.domain === undefined ||
-                        Object.keys(matcher.domain).length === 0 ||
-                        (axisSpec.domain !== undefined &&
-                            Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))))));
-        default:
-            assertNever(predicate);
-    }
+function executePSpecPredicate(predicate, spec) {
+	switch (predicate.type) {
+		case "and":
+			for (const operator of predicate.operands) if (!executePSpecPredicate(operator, spec)) return false;
+			return true;
+		case "or":
+			for (const operator of predicate.operands) if (executePSpecPredicate(operator, spec)) return true;
+			return false;
+		case "not": return !executePSpecPredicate(predicate.operand, spec);
+		case "name": return require_spec.isPColumnSpec(spec) && spec.name === predicate.name;
+		case "name_pattern": return require_spec.isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
+		case "annotation": return require_spec.isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] === predicate.value;
+		case "annotation_pattern": return require_spec.isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] !== void 0 && Boolean(spec.annotations[predicate.annotation].match(predicate.pattern));
+		case "has_axes": return require_spec.isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))));
+		default: assertNever(predicate);
+	}
 }
 
+//#endregion
 exports.executePSpecPredicate = executePSpecPredicate;
-//# sourceMappingURL=query.cjs.map
+//# sourceMappingURL=query.cjs.map

package/dist/pool/query.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"query.cjs","sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"names":["spec","isPColumnSpec"],"mappings":";;;;AAoCA,SAAS,WAAW,CAAC,CAAQ,EAAA;IAC3B,MAAM,IAAI,KAAK,CAAC,qBAAqB,GAAG,CAAC,CAAC,CAAC;AAC7C;AAEM,SAAU,qBAAqB,CAAC,SAAyB,EAAEA,MAAiB,EAAA;AAChF,IAAA,QAAQ,SAAS,CAAC,IAAI;AACpB,QAAA,KAAK,KAAK;AACR,YAAA,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,QAAQ;AACvC,gBAAA,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAEA,MAAI,CAAC;AAAE,oBAAA,OAAO,KAAK;AAC1D,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,IAAI;AACP,YAAA,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,QAAQ;AACvC,gBAAA,IAAI,qBAAqB,CAAC,QAAQ,EAAEA,MAAI,CAAC;AAAE,oBAAA,OAAO,IAAI;AACxD,YAAA,OAAO,KAAK;AACd,QAAA,KAAK,KAAK;YACR,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,OAAO,EAAEA,MAAI,CAAC;AACxD,QAAA,KAAK,MAAM;AACT,YAAA,OAAOC,kBAAa,CAACD,MAAI,CAAC,IAAIA,MAAI,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI;AAC5D,QAAA,KAAK,cAAc;AACjB,YAAA,OAAOC,kBAAa,CAACD,MAAI,CAAC,IAAI,OAAO,CAACA,MAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAC3E,QAAA,KAAK,YAAY;AACf,YAAA,QACEC,kBAAa,CAACD,MAAI,CAAC;gBACnBA,MAAI,CAAC,WAAW,KAAK,SAAS;AAC9B,gBAAAA,MAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,SAAS,CAAC,KAAK;AAE9D,QAAA,KAAK,oBAAoB;AACvB,YAAA,QACEC,kBAAa,CAACD,MAAI,CAAC;gBACnBA,MAAI,CAAC,WAAW,KAAK,SAAS;gBAC9BA,MAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,SAAS;AACpD,gBAAA,OAAO,CAACA,MAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAE5E,QAAA,KAAK,UAAU;AACb,YAAA,QACEC,kBAAa,CAACD,MAAI,CAAC;AACnB,gBAAA,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,KAC3BA,MAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,CAAC,QAAQ,KACP,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;AAC7D,qBAAC,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC;AAC9D,qBAAC,OAAO,CAAC,MAAM,KAAK,SAAS;wBAC3B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;AACxC,yBAAC,QAAQ,CAAC,MAAM,KAAK,SAAS;AAC5B,4BAAA,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,CAClC,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,QAAQ,CAAC,MAAO,CAAC,MAAM,CAAC,KAAK,WAAW,CACpE,CAAC,CAAC,CACV,CACF;AAEL,QAAA;YACE,WAAW,CAAC,SAAS,CAAC;;AAE5B;;;;"}
+{"version":3,"file":"query.cjs","names":["isPColumnSpec"],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAOA,2BAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAOA,2BAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACEA,2BAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACEA,2BAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}

package/dist/pool/query.d.ts

@@ -1,28 +1,33 @@
-import type { AxisId } from "../drivers";
-import type { PObjectSpec } from "./spec";
-export type PSpecPredicate = {
-    type: "and" | "or";
-    operands: PSpecPredicate[];
+import { PObjectSpec } from "./spec.js";
+import { AxisId } from "../drivers/pframe/spec/spec.js";
+import "../drivers/index.js";
+
+//#region src/pool/query.d.ts
+type PSpecPredicate = {
+  type: "and" | "or";
+  operands: PSpecPredicate[];
 } | {
-    type: "not";
-    operand: PSpecPredicate;
+  type: "not";
+  operand: PSpecPredicate;
 } | {
-    type: "name";
-    name: string;
+  type: "name";
+  name: string;
 } | {
-    type: "name_pattern";
-    pattern: string;
+  type: "name_pattern";
+  pattern: string;
 } | {
-    type: "annotation";
-    annotation: string;
-    value: string;
+  type: "annotation";
+  annotation: string;
+  value: string;
 } | {
-    type: "annotation_pattern";
-    annotation: string;
-    pattern: string;
+  type: "annotation_pattern";
+  annotation: string;
+  pattern: string;
 } | {
-    type: "has_axes";
-    axes: Partial<AxisId>[];
+  type: "has_axes";
+  axes: Partial<AxisId>[];
 };
-export declare function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean;
+declare function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean;
+//#endregion
+export { PSpecPredicate, executePSpecPredicate };
 //# sourceMappingURL=query.d.ts.map

package/dist/pool/query.js

@@ -1,47 +1,27 @@
-import { isPColumnSpec } from './spec.js';
+import { isPColumnSpec } from "./spec.js";
 
+//#region src/pool/query.ts
 function assertNever(x) {
-    throw new Error("Unexpected object: " + x); // This is ok, because this is a possible runtime error
+	throw new Error("Unexpected object: " + x);
 }
 function executePSpecPredicate(predicate, spec) {
-    switch (predicate.type) {
-        case "and":
-            for (const operator of predicate.operands)
-                if (!executePSpecPredicate(operator, spec))
-                    return false;
-            return true;
-        case "or":
-            for (const operator of predicate.operands)
-                if (executePSpecPredicate(operator, spec))
-                    return true;
-            return false;
-        case "not":
-            return !executePSpecPredicate(predicate.operand, spec);
-        case "name":
-            return isPColumnSpec(spec) && spec.name === predicate.name;
-        case "name_pattern":
-            return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
-        case "annotation":
-            return (isPColumnSpec(spec) &&
-                spec.annotations !== undefined &&
-                spec.annotations[predicate.annotation] === predicate.value);
-        case "annotation_pattern":
-            return (isPColumnSpec(spec) &&
-                spec.annotations !== undefined &&
-                spec.annotations[predicate.annotation] !== undefined &&
-                Boolean(spec.annotations[predicate.annotation].match(predicate.pattern)));
-        case "has_axes":
-            return (isPColumnSpec(spec) &&
-                predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === undefined || matcher.type === axisSpec.type) &&
-                    (matcher.name === undefined || matcher.name === axisSpec.name) &&
-                    (matcher.domain === undefined ||
-                        Object.keys(matcher.domain).length === 0 ||
-                        (axisSpec.domain !== undefined &&
-                            Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))))));
-        default:
-            assertNever(predicate);
-    }
+	switch (predicate.type) {
+		case "and":
+			for (const operator of predicate.operands) if (!executePSpecPredicate(operator, spec)) return false;
+			return true;
+		case "or":
+			for (const operator of predicate.operands) if (executePSpecPredicate(operator, spec)) return true;
+			return false;
+		case "not": return !executePSpecPredicate(predicate.operand, spec);
+		case "name": return isPColumnSpec(spec) && spec.name === predicate.name;
+		case "name_pattern": return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
+		case "annotation": return isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] === predicate.value;
+		case "annotation_pattern": return isPColumnSpec(spec) && spec.annotations !== void 0 && spec.annotations[predicate.annotation] !== void 0 && Boolean(spec.annotations[predicate.annotation].match(predicate.pattern));
+		case "has_axes": return isPColumnSpec(spec) && predicate.axes.every((matcher) => spec.axesSpec.some((axisSpec) => (matcher.type === void 0 || matcher.type === axisSpec.type) && (matcher.name === void 0 || matcher.name === axisSpec.name) && (matcher.domain === void 0 || Object.keys(matcher.domain).length === 0 || axisSpec.domain !== void 0 && Object.entries(matcher.domain).every(([domain, domainValue]) => axisSpec.domain[domain] === domainValue))));
+		default: assertNever(predicate);
+	}
 }
 
+//#endregion
 export { executePSpecPredicate };
-//# sourceMappingURL=query.js.map
+//# sourceMappingURL=query.js.map

package/dist/pool/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"names":[],"mappings":";;AAoCA,SAAS,WAAW,CAAC,CAAQ,EAAA;IAC3B,MAAM,IAAI,KAAK,CAAC,qBAAqB,GAAG,CAAC,CAAC,CAAC;AAC7C;AAEM,SAAU,qBAAqB,CAAC,SAAyB,EAAE,IAAiB,EAAA;AAChF,IAAA,QAAQ,SAAS,CAAC,IAAI;AACpB,QAAA,KAAK,KAAK;AACR,YAAA,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,QAAQ;AACvC,gBAAA,IAAI,CAAC,qBAAqB,CAAC,QAAQ,EAAE,IAAI,CAAC;AAAE,oBAAA,OAAO,KAAK;AAC1D,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,IAAI;AACP,YAAA,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,QAAQ;AACvC,gBAAA,IAAI,qBAAqB,CAAC,QAAQ,EAAE,IAAI,CAAC;AAAE,oBAAA,OAAO,IAAI;AACxD,YAAA,OAAO,KAAK;AACd,QAAA,KAAK,KAAK;YACR,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC;AACxD,QAAA,KAAK,MAAM;AACT,YAAA,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI;AAC5D,QAAA,KAAK,cAAc;AACjB,YAAA,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAC3E,QAAA,KAAK,YAAY;AACf,YAAA,QACE,aAAa,CAAC,IAAI,CAAC;gBACnB,IAAI,CAAC,WAAW,KAAK,SAAS;AAC9B,gBAAA,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,SAAS,CAAC,KAAK;AAE9D,QAAA,KAAK,oBAAoB;AACvB,YAAA,QACE,aAAa,CAAC,IAAI,CAAC;gBACnB,IAAI,CAAC,WAAW,KAAK,SAAS;gBAC9B,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,KAAK,SAAS;AACpD,gBAAA,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAE5E,QAAA,KAAK,UAAU;AACb,YAAA,QACE,aAAa,CAAC,IAAI,CAAC;AACnB,gBAAA,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,OAAO,KAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,CAAC,QAAQ,KACP,CAAC,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI;AAC7D,qBAAC,OAAO,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,CAAC;AAC9D,qBAAC,OAAO,CAAC,MAAM,KAAK,SAAS;wBAC3B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;AACxC,yBAAC,QAAQ,CAAC,MAAM,KAAK,SAAS;AAC5B,4BAAA,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,CAClC,CAAC,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,QAAQ,CAAC,MAAO,CAAC,MAAM,CAAC,KAAK,WAAW,CACpE,CAAC,CAAC,CACV,CACF;AAEL,QAAA;YACE,WAAW,CAAC,SAAS,CAAC;;AAE5B;;;;"}
+{"version":3,"file":"query.js","names":[],"sources":["../../src/pool/query.ts"],"sourcesContent":["import type { AxisId } from \"../drivers\";\nimport type { PObjectSpec } from \"./spec\";\nimport { isPColumnSpec } from \"./spec\";\n\nexport type PSpecPredicate =\n  | {\n      type: \"and\" | \"or\";\n      operands: PSpecPredicate[];\n    }\n  | {\n      type: \"not\";\n      operand: PSpecPredicate;\n    }\n  | {\n      type: \"name\";\n      name: string;\n    }\n  | {\n      type: \"name_pattern\";\n      pattern: string;\n    }\n  | {\n      type: \"annotation\";\n      annotation: string;\n      value: string;\n    }\n  | {\n      type: \"annotation_pattern\";\n      annotation: string;\n      pattern: string;\n    }\n  | {\n      type: \"has_axes\";\n      axes: Partial<AxisId>[];\n    };\n\nfunction assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x); // This is ok, because this is a possible runtime error\n}\n\nexport function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {\n  switch (predicate.type) {\n    case \"and\":\n      for (const operator of predicate.operands)\n        if (!executePSpecPredicate(operator, spec)) return false;\n      return true;\n    case \"or\":\n      for (const operator of predicate.operands)\n        if (executePSpecPredicate(operator, spec)) return true;\n      return false;\n    case \"not\":\n      return !executePSpecPredicate(predicate.operand, spec);\n    case \"name\":\n      return isPColumnSpec(spec) && spec.name === predicate.name;\n    case \"name_pattern\":\n      return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));\n    case \"annotation\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] === predicate.value\n      );\n    case \"annotation_pattern\":\n      return (\n        isPColumnSpec(spec) &&\n        spec.annotations !== undefined &&\n        spec.annotations[predicate.annotation] !== undefined &&\n        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))\n      );\n    case \"has_axes\":\n      return (\n        isPColumnSpec(spec) &&\n        predicate.axes.every((matcher) =>\n          spec.axesSpec.some(\n            (axisSpec) =>\n              (matcher.type === undefined || matcher.type === axisSpec.type) &&\n              (matcher.name === undefined || matcher.name === axisSpec.name) &&\n              (matcher.domain === undefined ||\n                Object.keys(matcher.domain).length === 0 ||\n                (axisSpec.domain !== undefined &&\n                  Object.entries(matcher.domain).every(\n                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,\n                  ))),\n          ),\n        )\n      );\n    default:\n      assertNever(predicate);\n  }\n}\n"],"mappings":";;;AAoCA,SAAS,YAAY,GAAiB;AACpC,OAAM,IAAI,MAAM,wBAAwB,EAAE;;AAG5C,SAAgB,sBAAsB,WAA2B,MAA4B;AAC3F,SAAQ,UAAU,MAAlB;EACE,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,CAAC,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACrD,UAAO;EACT,KAAK;AACH,QAAK,MAAM,YAAY,UAAU,SAC/B,KAAI,sBAAsB,UAAU,KAAK,CAAE,QAAO;AACpD,UAAO;EACT,KAAK,MACH,QAAO,CAAC,sBAAsB,UAAU,SAAS,KAAK;EACxD,KAAK,OACH,QAAO,cAAc,KAAK,IAAI,KAAK,SAAS,UAAU;EACxD,KAAK,eACH,QAAO,cAAc,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,UAAU,QAAQ,CAAC;EAC3E,KAAK,aACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAAU;EAEzD,KAAK,qBACH,QACE,cAAc,KAAK,IACnB,KAAK,gBAAgB,UACrB,KAAK,YAAY,UAAU,gBAAgB,UAC3C,QAAQ,KAAK,YAAY,UAAU,YAAY,MAAM,UAAU,QAAQ,CAAC;EAE5E,KAAK,WACH,QACE,cAAc,KAAK,IACnB,UAAU,KAAK,OAAO,YACpB,KAAK,SAAS,MACX,cACE,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,SAAS,UAAa,QAAQ,SAAS,SAAS,UACxD,QAAQ,WAAW,UAClB,OAAO,KAAK,QAAQ,OAAO,CAAC,WAAW,KACtC,SAAS,WAAW,UACnB,OAAO,QAAQ,QAAQ,OAAO,CAAC,OAC5B,CAAC,QAAQ,iBAAiB,SAAS,OAAQ,YAAY,YACzD,EACR,CACF;EAEL,QACE,aAAY,UAAU"}

package/dist/pool/spec.cjs

@@ -1,65 +1,58 @@
-'use strict';
-
-var util = require('../util.cjs');
+const require_util = require('../util.cjs');
 
+//#region src/pool/spec.ts
 function isPColumnSpec(spec) {
-    return spec.kind === "PColumn";
+	return spec.kind === "PColumn";
 }
 function isPColumn(obj) {
-    return isPColumnSpec(obj.spec);
+	return isPColumnSpec(obj.spec);
 }
 function isPColumnSpecResult(r) {
-    return isPColumnSpec(r.obj);
+	return isPColumnSpec(r.obj);
 }
 function isPColumnResult(r) {
-    return isPColumnSpec(r.obj.spec);
+	return isPColumnSpec(r.obj.spec);
 }
 function ensurePColumn(obj) {
-    if (!isPColumn(obj))
-        throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
-    return obj;
+	if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
+	return obj;
 }
 function mapPObjectData(pObj, cb) {
-    return pObj === undefined
-        ? undefined
-        : {
-            ...pObj,
-            data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data),
-        };
+	return pObj === void 0 ? void 0 : {
+		...pObj,
+		data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data)
+	};
 }
 function extractAllColumns(entry) {
-    const columns = new Map();
-    const addAllColumns = (entry) => {
-        switch (entry.type) {
-            case "column":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "slicedColumn":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "artificialColumn":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "inlineColumn":
-                return;
-            case "full":
-            case "inner":
-                for (const e of entry.entries)
-                    addAllColumns(e);
-                return;
-            case "outer":
-                addAllColumns(entry.primary);
-                for (const e of entry.secondary)
-                    addAllColumns(e);
-                return;
-            default:
-                util.assertNever(entry);
-        }
-    };
-    addAllColumns(entry);
-    return [...columns.values()];
+	const columns = /* @__PURE__ */ new Map();
+	const addAllColumns = (entry) => {
+		switch (entry.type) {
+			case "column":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "slicedColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "artificialColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "inlineColumn": return;
+			case "full":
+			case "inner":
+				for (const e of entry.entries) addAllColumns(e);
+				return;
+			case "outer":
+				addAllColumns(entry.primary);
+				for (const e of entry.secondary) addAllColumns(e);
+				return;
+			default: require_util.assertNever(entry);
+		}
+	};
+	addAllColumns(entry);
+	return [...columns.values()];
 }
 
+//#endregion
 exports.ensurePColumn = ensurePColumn;
 exports.extractAllColumns = extractAllColumns;
 exports.isPColumn = isPColumn;
@@ -67,4 +60,4 @@ exports.isPColumnResult = isPColumnResult;
 exports.isPColumnSpec = isPColumnSpec;
 exports.isPColumnSpecResult = isPColumnSpecResult;
 exports.mapPObjectData = mapPObjectData;
-//# sourceMappingURL=spec.cjs.map
+//# sourceMappingURL=spec.cjs.map

package/dist/pool/spec.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"spec.cjs","sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"names":["assertNever"],"mappings":";;;;AAuCM,SAAU,aAAa,CAAC,IAAiB,EAAA;AAC7C,IAAA,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS;AAChC;AAEM,SAAU,SAAS,CAAI,GAAe,EAAA;AAC1C,IAAA,OAAO,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC;AAChC;AAEM,SAAU,mBAAmB,CACjC,CAA+B,EAAA;AAE/B,IAAA,OAAO,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC;AAC7B;AAEM,SAAU,eAAe,CAC7B,CAA8B,EAAA;IAE9B,OAAO,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;AAClC;AAEM,SAAU,aAAa,CAAI,GAAe,EAAA;AAC9C,IAAA,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,CAAA,sBAAA,EAAyB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAA,CAAA,CAAG,CAAC;AAC/E,IAAA,OAAO,GAAG;AACZ;AAgBM,SAAU,cAAc,CAC5B,IAA6B,EAC7B,EAAiB,EAAA;IAEjB,OAAO,IAAI,KAAK;AACd,UAAE;AACF,UAAE;AACE,YAAA,GAAG,IAAI;YACP,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,GAAG,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC;SACpE;AACP;AAEM,SAAU,iBAAiB,CAAI,KAA4B,EAAA;AAC/D,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,EAAyB;AAChD,IAAA,MAAM,aAAa,GAAG,CAAC,KAA4B,KAAI;AACrD,QAAA,QAAQ,KAAK,CAAC,IAAI;AAChB,YAAA,KAAK,QAAQ;AACX,gBAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;gBAC1C;AACF,YAAA,KAAK,cAAc;AACjB,gBAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;gBAC1C;AACF,YAAA,KAAK,kBAAkB;AACrB,gBAAA,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,CAAC;gBAC1C;AACF,YAAA,KAAK,cAAc;gBACjB;AACF,YAAA,KAAK,MAAM;AACX,YAAA,KAAK,OAAO;AACV,gBAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO;oBAAE,aAAa,CAAC,CAAC,CAAC;gBAC/C;AACF,YAAA,KAAK,OAAO;AACV,gBAAA,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC;AAC5B,gBAAA,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,SAAS;oBAAE,aAAa,CAAC,CAAC,CAAC;gBACjD;AACF,YAAA;gBACEA,gBAAW,CAAC,KAAK,CAAC;;AAExB,IAAA,CAAC;IACD,aAAa,CAAC,KAAK,CAAC;AACpB,IAAA,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;AAC9B;;;;;;;;;;"}
+{"version":3,"file":"spec.cjs","names":[],"sources":["../../src/pool/spec.ts"],"sourcesContent":["import type { Branded } from \"../branding\";\nimport type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from \"../drivers\";\nimport { assertNever } from \"../util\";\nimport type { ResultPoolEntry } from \"./entry\";\n\n/** Any object exported into the result pool by the block always have spec attached to it */\nexport type PObjectSpec = {\n  /** PObject kind discriminator */\n  readonly kind: string;\n\n  /** Name is common part of PObject identity */\n  readonly name: string;\n\n  /** Domain is a set of key-value pairs that can be used to identify the object */\n  readonly domain?: Record<string, string>;\n\n  /** Additional information attached to the object */\n  readonly annotations?: Record<string, string>;\n};\n\n/** Stable PObject id */\nexport type PObjectId = Branded<string, \"PColumnId\">;\n\n/**\n * Full PObject representation.\n *\n * @template Data type of the object referencing or describing the \"data\" part of the PObject\n * */\nexport interface PObject<Data> {\n  /** Fully rendered PObjects are assigned a stable identifier. */\n  readonly id: PObjectId;\n\n  /** PObject spec, allowing it to be found among other PObjects */\n  readonly spec: PObjectSpec;\n\n  /** A handle to data object */\n  readonly data: Data;\n}\n\nexport function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {\n  return spec.kind === \"PColumn\";\n}\n\nexport function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {\n  return isPColumnSpec(obj.spec);\n}\n\nexport function isPColumnSpecResult(\n  r: ResultPoolEntry<PObjectSpec>,\n): r is ResultPoolEntry<PColumnSpec> {\n  return isPColumnSpec(r.obj);\n}\n\nexport function isPColumnResult<T>(\n  r: ResultPoolEntry<PObject<T>>,\n): r is ResultPoolEntry<PColumn<T>> {\n  return isPColumnSpec(r.obj.spec);\n}\n\nexport function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {\n  if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);\n  return obj;\n}\n\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | PColumnLazy<D1>,\n  cb: (d: D1) => D2,\n): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PColumn<D1> | undefined,\n  cb: (d: D1) => D2,\n): PColumn<D2> | undefined;\nexport function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined;\nexport function mapPObjectData<D1, D2>(\n  pObj: PObject<D1> | undefined,\n  cb: (d: D1) => D2,\n): PObject<D2> | undefined {\n  return pObj === undefined\n    ? undefined\n    : {\n        ...pObj,\n        data: cb(typeof pObj.data === \"function\" ? pObj.data() : pObj.data),\n      };\n}\n\nexport function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[] {\n  const columns = new Map<PObjectId, PColumn<D>>();\n  const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {\n    switch (entry.type) {\n      case \"column\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"slicedColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"artificialColumn\":\n        columns.set(entry.column.id, entry.column);\n        return;\n      case \"inlineColumn\":\n        return;\n      case \"full\":\n      case \"inner\":\n        for (const e of entry.entries) addAllColumns(e);\n        return;\n      case \"outer\":\n        addAllColumns(entry.primary);\n        for (const e of entry.secondary) addAllColumns(e);\n        return;\n      default:\n        assertNever(entry);\n    }\n  };\n  addAllColumns(entry);\n  return [...columns.values()];\n}\n"],"mappings":";;;AAuCA,SAAgB,cAAc,MAAwC;AACpE,QAAO,KAAK,SAAS;;AAGvB,SAAgB,UAAa,KAAoC;AAC/D,QAAO,cAAc,IAAI,KAAK;;AAGhC,SAAgB,oBACd,GACmC;AACnC,QAAO,cAAc,EAAE,IAAI;;AAG7B,SAAgB,gBACd,GACkC;AAClC,QAAO,cAAc,EAAE,IAAI,KAAK;;AAGlC,SAAgB,cAAiB,KAA6B;AAC5D,KAAI,CAAC,UAAU,IAAI,CAAE,OAAM,IAAI,MAAM,yBAAyB,IAAI,KAAK,KAAK,GAAG;AAC/E,QAAO;;AAiBT,SAAgB,eACd,MACA,IACyB;AACzB,QAAO,SAAS,SACZ,SACA;EACE,GAAG;EACH,MAAM,GAAG,OAAO,KAAK,SAAS,aAAa,KAAK,MAAM,GAAG,KAAK,KAAK;EACpE;;AAGP,SAAgB,kBAAqB,OAA4C;CAC/E,MAAM,0BAAU,IAAI,KAA4B;CAChD,MAAM,iBAAiB,UAAiC;AACtD,UAAQ,MAAM,MAAd;GACE,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK;AACH,YAAQ,IAAI,MAAM,OAAO,IAAI,MAAM,OAAO;AAC1C;GACF,KAAK,eACH;GACF,KAAK;GACL,KAAK;AACH,SAAK,MAAM,KAAK,MAAM,QAAS,eAAc,EAAE;AAC/C;GACF,KAAK;AACH,kBAAc,MAAM,QAAQ;AAC5B,SAAK,MAAM,KAAK,MAAM,UAAW,eAAc,EAAE;AACjD;GACF,QACE,0BAAY,MAAM;;;AAGxB,eAAc,MAAM;AACpB,QAAO,CAAC,GAAG,QAAQ,QAAQ,CAAC"}

package/dist/pool/spec.d.ts

@@ -1,41 +1,43 @@
-import type { Branded } from "../branding";
-import type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from "../drivers";
-import type { ResultPoolEntry } from "./entry";
+import { Branded } from "../branding.js";
+import { ResultPoolEntry } from "./entry.js";
+import { PColumn, PColumnLazy, PColumnSpec } from "../drivers/pframe/spec/spec.js";
+import { JoinEntry } from "../drivers/pframe/table_calculate.js";
+import "../drivers/index.js";
+
+//#region src/pool/spec.d.ts
 /** Any object exported into the result pool by the block always have spec attached to it */
-export type PObjectSpec = {
-    /** PObject kind discriminator */
-    readonly kind: string;
-    /** Name is common part of PObject identity */
-    readonly name: string;
-    /** Domain is a set of key-value pairs that can be used to identify the object */
-    readonly domain?: Record<string, string>;
-    /** Additional information attached to the object */
-    readonly annotations?: Record<string, string>;
+type PObjectSpec = {
+  /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
+  readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
+  readonly domain?: Record<string, string>; /** Additional information attached to the object */
+  readonly annotations?: Record<string, string>;
 };
 /** Stable PObject id */
-export type PObjectId = Branded<string, "PColumnId">;
+type PObjectId = Branded<string, "PColumnId">;
 /**
  * Full PObject representation.
  *
  * @template Data type of the object referencing or describing the "data" part of the PObject
  * */
-export interface PObject<Data> {
-    /** Fully rendered PObjects are assigned a stable identifier. */
-    readonly id: PObjectId;
-    /** PObject spec, allowing it to be found among other PObjects */
-    readonly spec: PObjectSpec;
-    /** A handle to data object */
-    readonly data: Data;
+interface PObject<Data> {
+  /** Fully rendered PObjects are assigned a stable identifier. */
+  readonly id: PObjectId;
+  /** PObject spec, allowing it to be found among other PObjects */
+  readonly spec: PObjectSpec;
+  /** A handle to data object */
+  readonly data: Data;
 }
-export declare function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec;
-export declare function isPColumn<T>(obj: PObject<T>): obj is PColumn<T>;
-export declare function isPColumnSpecResult(r: ResultPoolEntry<PObjectSpec>): r is ResultPoolEntry<PColumnSpec>;
-export declare function isPColumnResult<T>(r: ResultPoolEntry<PObject<T>>): r is ResultPoolEntry<PColumn<T>>;
-export declare function ensurePColumn<T>(obj: PObject<T>): PColumn<T>;
-export declare function mapPObjectData<D1, D2>(pObj: PColumn<D1> | PColumnLazy<D1>, cb: (d: D1) => D2): PColumn<D2>;
-export declare function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;
-export declare function mapPObjectData<D1, D2>(pObj: PColumn<D1> | undefined, cb: (d: D1) => D2): PColumn<D2> | undefined;
-export declare function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;
-export declare function mapPObjectData<D1, D2>(pObj: PObject<D1> | undefined, cb: (d: D1) => D2): PObject<D2> | undefined;
-export declare function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[];
+declare function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec;
+declare function isPColumn<T>(obj: PObject<T>): obj is PColumn<T>;
+declare function isPColumnSpecResult(r: ResultPoolEntry<PObjectSpec>): r is ResultPoolEntry<PColumnSpec>;
+declare function isPColumnResult<T>(r: ResultPoolEntry<PObject<T>>): r is ResultPoolEntry<PColumn<T>>;
+declare function ensurePColumn<T>(obj: PObject<T>): PColumn<T>;
+declare function mapPObjectData<D1, D2>(pObj: PColumn<D1> | PColumnLazy<D1>, cb: (d: D1) => D2): PColumn<D2>;
+declare function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;
+declare function mapPObjectData<D1, D2>(pObj: PColumn<D1> | undefined, cb: (d: D1) => D2): PColumn<D2> | undefined;
+declare function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;
+declare function mapPObjectData<D1, D2>(pObj: PObject<D1> | undefined, cb: (d: D1) => D2): PObject<D2> | undefined;
+declare function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[];
+//#endregion
+export { PObject, PObjectId, PObjectSpec, ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, mapPObjectData };
 //# sourceMappingURL=spec.d.ts.map

package/dist/pool/spec.js

@@ -1,62 +1,57 @@
-import { assertNever } from '../util.js';
+import { assertNever } from "../util.js";
 
+//#region src/pool/spec.ts
 function isPColumnSpec(spec) {
-    return spec.kind === "PColumn";
+	return spec.kind === "PColumn";
 }
 function isPColumn(obj) {
-    return isPColumnSpec(obj.spec);
+	return isPColumnSpec(obj.spec);
 }
 function isPColumnSpecResult(r) {
-    return isPColumnSpec(r.obj);
+	return isPColumnSpec(r.obj);
 }
 function isPColumnResult(r) {
-    return isPColumnSpec(r.obj.spec);
+	return isPColumnSpec(r.obj.spec);
 }
 function ensurePColumn(obj) {
-    if (!isPColumn(obj))
-        throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
-    return obj;
+	if (!isPColumn(obj)) throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
+	return obj;
 }
 function mapPObjectData(pObj, cb) {
-    return pObj === undefined
-        ? undefined
-        : {
-            ...pObj,
-            data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data),
-        };
+	return pObj === void 0 ? void 0 : {
+		...pObj,
+		data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data)
+	};
 }
 function extractAllColumns(entry) {
-    const columns = new Map();
-    const addAllColumns = (entry) => {
-        switch (entry.type) {
-            case "column":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "slicedColumn":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "artificialColumn":
-                columns.set(entry.column.id, entry.column);
-                return;
-            case "inlineColumn":
-                return;
-            case "full":
-            case "inner":
-                for (const e of entry.entries)
-                    addAllColumns(e);
-                return;
-            case "outer":
-                addAllColumns(entry.primary);
-                for (const e of entry.secondary)
-                    addAllColumns(e);
-                return;
-            default:
-                assertNever(entry);
-        }
-    };
-    addAllColumns(entry);
-    return [...columns.values()];
+	const columns = /* @__PURE__ */ new Map();
+	const addAllColumns = (entry) => {
+		switch (entry.type) {
+			case "column":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "slicedColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "artificialColumn":
+				columns.set(entry.column.id, entry.column);
+				return;
+			case "inlineColumn": return;
+			case "full":
+			case "inner":
+				for (const e of entry.entries) addAllColumns(e);
+				return;
+			case "outer":
+				addAllColumns(entry.primary);
+				for (const e of entry.secondary) addAllColumns(e);
+				return;
+			default: assertNever(entry);
+		}
+	};
+	addAllColumns(entry);
+	return [...columns.values()];
 }
 
+//#endregion
 export { ensurePColumn, extractAllColumns, isPColumn, isPColumnResult, isPColumnSpec, isPColumnSpecResult, mapPObjectData };
-//# sourceMappingURL=spec.js.map
+//# sourceMappingURL=spec.js.map