@bcts/envelope-pattern 1.0.0-alpha.12 → 1.0.0-alpha.14

package/README.md

@@ -10,4 +10,4 @@ The pattern language is designed to be expressive yet concise, allowing you to m
 
 ## Rust Reference Implementation
 
-This TypeScript implementation is based on [bc-envelope-pattern-rust](https://github.com/BlockchainCommons/bc-envelope-pattern-rust) **v0.11.0**.
+This TypeScript implementation is based on [bc-envelope-pattern-rust](https://github.com/BlockchainCommons/bc-envelope-pattern-rust) **v0.11.0** ([commit](https://github.com/BlockchainCommons/bc-envelope-pattern-rust/tree/35c8ea1af47eed148649c5462e66aed9a5064620)).

package/dist/index.cjs

@@ -497,6 +497,26 @@ function compileAsAtomic(pat, code, literals, _captures) {
 		literalIndex: idx
 	});
 }
+/**
+* Registry for pattern matching function to break circular dependencies.
+* This allows meta patterns to match child patterns without importing from index.ts.
+*/
+let patternMatchFn;
+/**
+* Registers the pattern match function.
+* Called from index.ts after all patterns are defined.
+*/
+function registerPatternMatchFn(fn) {
+	patternMatchFn = fn;
+}
+/**
+* Match a pattern against an envelope using the registered match function.
+* Used by meta patterns to match child patterns.
+*/
+function matchPattern(pattern, haystack) {
+	if (patternMatchFn === void 0) throw new Error("Pattern match function not registered");
+	return patternMatchFn(pattern, haystack);
+}
 
 //#endregion
 //#region src/pattern/leaf/bool-pattern.ts
@@ -3389,9 +3409,7 @@ var AndPattern = class AndPattern {
 		return this.#patterns;
 	}
 	pathsWithCaptures(haystack) {
-		return [this.#patterns.every((pattern) => {
-			return pattern.matches(haystack);
-		}) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [this.#patterns.every((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -3453,9 +3471,7 @@ var OrPattern = class OrPattern {
 		return this.#patterns;
 	}
 	pathsWithCaptures(haystack) {
-		return [this.#patterns.some((pattern) => {
-			return pattern.matches(haystack);
-		}) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [this.#patterns.some((pattern) => matchPattern(pattern, haystack)) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -3550,7 +3566,7 @@ var NotPattern = class NotPattern {
 		return this.#pattern;
 	}
 	pathsWithCaptures(haystack) {
-		return [!this.#pattern.matches(haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
+		return [!matchPattern(this.#pattern, haystack) ? [[haystack]] : [], /* @__PURE__ */ new Map()];
 	}
 	paths(haystack) {
 		return this.pathsWithCaptures(haystack)[0];
@@ -4811,6 +4827,139 @@ function compileMetaPattern(pattern, code, literals, captureNames) {
 	}
 }
 
+//#endregion
+//#region src/pattern/dcbor-integration.ts
+/**
+* Convert a dcbor-pattern Pattern to a bc-envelope-pattern Pattern.
+*
+* This function serves as the bridge between the two pattern systems,
+* allowing dcbor-pattern expressions to be used in envelope pattern contexts.
+*
+* @param dcborPattern - The dcbor-pattern Pattern to convert
+* @returns The converted envelope pattern, or an error if conversion fails
+*/
+function convertDcborPatternToEnvelopePattern(dcborPattern) {
+	switch (dcborPattern.kind) {
+		case "Value": return convertValuePatternToEnvelopePattern(dcborPattern.pattern);
+		case "Structure": return convertStructurePatternToEnvelopePattern(dcborPattern.pattern);
+		case "Meta": return convertMetaPatternToEnvelopePattern(dcborPattern.pattern, dcborPattern);
+	}
+}
+/**
+* Convert a dcbor-pattern ValuePattern to an envelope leaf pattern.
+*/
+function convertValuePatternToEnvelopePattern(valuePattern) {
+	switch (valuePattern.type) {
+		case "Bool": return ok({
+			type: "Leaf",
+			pattern: leafBool(BoolPattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "Number": return ok({
+			type: "Leaf",
+			pattern: leafNumber(NumberPattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "Text": return ok({
+			type: "Leaf",
+			pattern: leafText(TextPattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "ByteString": return ok({
+			type: "Leaf",
+			pattern: leafByteString(ByteStringPattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "Date": return ok({
+			type: "Leaf",
+			pattern: leafDate(DatePattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "KnownValue": return ok({
+			type: "Leaf",
+			pattern: leafKnownValue(KnownValuePattern.fromDcborPattern(valuePattern.pattern))
+		});
+		case "Null": return ok({
+			type: "Leaf",
+			pattern: leafNull(NullPattern.new())
+		});
+		case "Digest": return ok({
+			type: "Leaf",
+			pattern: leafCbor(CBORPattern.fromDcborPattern({
+				kind: "Value",
+				pattern: valuePattern
+			}))
+		});
+	}
+}
+/**
+* Convert a dcbor-pattern StructurePattern to an envelope pattern.
+*/
+function convertStructurePatternToEnvelopePattern(structurePattern) {
+	switch (structurePattern.type) {
+		case "Array": return ok({
+			type: "Leaf",
+			pattern: leafArray(ArrayPattern.fromDcborPattern({
+				kind: "Structure",
+				pattern: structurePattern
+			}))
+		});
+		case "Map": return ok({
+			type: "Leaf",
+			pattern: leafMap(MapPattern.any())
+		});
+		case "Tagged": return ok({
+			type: "Leaf",
+			pattern: leafTag(TaggedPattern.fromDcborPattern(structurePattern.pattern))
+		});
+	}
+}
+/**
+* Convert a dcbor-pattern MetaPattern to an envelope meta pattern.
+*/
+function convertMetaPatternToEnvelopePattern(metaPattern, originalPattern) {
+	switch (metaPattern.type) {
+		case "Any": return ok({
+			type: "Meta",
+			pattern: metaAny(AnyPattern.new())
+		});
+		case "And": {
+			const convertedPatterns = [];
+			for (const pattern of metaPattern.pattern.patterns) {
+				const result = convertDcborPatternToEnvelopePattern(pattern);
+				if (!result.ok) return result;
+				convertedPatterns.push(result.value);
+			}
+			return ok({
+				type: "Meta",
+				pattern: metaAnd(AndPattern.new(convertedPatterns))
+			});
+		}
+		case "Or": {
+			const convertedPatterns = [];
+			for (const pattern of metaPattern.pattern.patterns) {
+				const result = convertDcborPatternToEnvelopePattern(pattern);
+				if (!result.ok) return result;
+				convertedPatterns.push(result.value);
+			}
+			return ok({
+				type: "Meta",
+				pattern: metaOr(OrPattern.new(convertedPatterns))
+			});
+		}
+		case "Not": {
+			const innerResult = convertDcborPatternToEnvelopePattern(metaPattern.pattern.pattern);
+			if (!innerResult.ok) return innerResult;
+			return ok({
+				type: "Meta",
+				pattern: metaNot(NotPattern.new(innerResult.value))
+			});
+		}
+		case "Capture":
+		case "Repeat":
+		case "Search":
+		case "Sequence": return ok({
+			type: "Leaf",
+			pattern: leafCbor(CBORPattern.fromDcborPattern(originalPattern))
+		});
+	}
+}
+
 //#endregion
 //#region src/pattern/index.ts
 /**
@@ -5268,6 +5417,7 @@ function registerAllFactories() {
 }
 registerAllFactories();
 registerVMPatternFunctions(patternPathsWithCaptures, patternMatches, patternPaths);
+registerPatternMatchFn(patternMatches);
 
 //#endregion
 //#region src/parse/token.ts
@@ -6021,7 +6171,7 @@ function parse(input) {
 	const result = parseOr(lexer);
 	if (!result.ok) {
 		const dcborResult = (0, _bcts_dcbor_pattern.parse)(input);
-		if (dcborResult.ok) return convertDcborPatternToEnvelopePattern(dcborResult.value);
+		if (dcborResult.ok) return convertDcborPatternToEnvelopePattern$1(dcborResult.value);
 		return result;
 	}
 	const next = lexer.next();
@@ -6040,7 +6190,7 @@ function parsePartial(input) {
 /**
 * Convert a dcbor-pattern Pattern to an envelope-pattern Pattern.
 */
-function convertDcborPatternToEnvelopePattern(_dcborPattern) {
+function convertDcborPatternToEnvelopePattern$1(_dcborPattern) {
 	return ok(any());
 }
 /**
@@ -6619,6 +6769,7 @@ exports.cborValue = cborValue;
 exports.compile = compile;
 exports.compileAsAtomic = compileAsAtomic;
 exports.compressed = compressed;
+exports.convertDcborPatternToEnvelopePattern = convertDcborPatternToEnvelopePattern;
 exports.date = date;
 exports.dateRange = dateRange;
 exports.dcborPatternError = dcborPatternError;
@@ -6677,6 +6828,7 @@ exports.leafPatternToString = leafPatternToString;
 exports.leafTag = leafTag;
 exports.leafText = leafText;
 exports.map = map;
+exports.matchPattern = matchPattern;
 exports.metaAnd = metaAnd;
 exports.metaAny = metaAny;
 exports.metaCapture = metaCapture;
@@ -6734,6 +6886,7 @@ exports.registerNumberPatternFactory = registerNumberPatternFactory;
 exports.registerObjectPatternFactory = registerObjectPatternFactory;
 exports.registerObscuredPatternFactory = registerObscuredPatternFactory;
 exports.registerOrPatternFactory = registerOrPatternFactory;
+exports.registerPatternMatchFn = registerPatternMatchFn;
 exports.registerPredicatePatternFactory = registerPredicatePatternFactory;
 exports.registerSearchPatternFactory = registerSearchPatternFactory;
 exports.registerSubjectPatternFactory = registerSubjectPatternFactory;