100% code coverage.

src/interpolate.mjs

@@ -40,6 +40,9 @@ function interpolateNode(node, ancestors) {
 					(value) => interpolateString(value, data.interp)
 				);
 			}
+			else {
+				node.properties[key] = '' + node.properties[key]
+			}
 		}
 	}
 
@@ -50,6 +53,14 @@ function interpolateNode(node, ancestors) {
 	return node;
 }
 
+
+function interpolateString(str, data) {
+	const context = createContext({ ...data, ...global });
+
+	const interpolatedStr = runInContext(`\`${str}\``, context);
+	return interpolatedStr;
+}
+/*
 function interpolateString(str, data) {
 	const context = createContext({ ...data, ...global });
 
@@ -61,5 +72,12 @@ function interpolateString(str, data) {
 		return str;
 	}
 }
+*/
+
+export const __testExports = {
+	getMaskedData,
+	interpolateNode,
+	interpolateString,
+}
 
 export default interpolate;

test/interpolate.test.mjs

@@ -1,7 +1,112 @@
-import interpolate from '../src/interpolate.mjs';
+import interpolate, { __testExports } from '../src/interpolate.mjs';
 import htmlToAst from '../src/html-to-ast.mjs';
 import astToHtml from '../src/ast-to-html.mjs';
 
+describe("interpolate()", () => {
+
+	it("should import", () => {
+		expect(interpolate).toBeDefined();
+	});
+
+	it("should handle nodes without properties", () => {
+		const node = {
+			type: 'text',
+			value: 'Test',
+			data: {},
+		};
+		const data = {};
+		expect(() => interpolate(node, data)).not.toThrow();
+	});
+
+	it("should handle nodes without data", () => {
+		const node = {
+			type: 'text',
+			value: 'Test',
+			data: {},
+		};
+		expect(() => interpolate(node)).not.toThrow();
+	});
+
+	it("should handle nodes with array properties", () => {
+		const node = {
+			properties: {
+				test: ['${value}'],
+			},
+			data: {},
+		};
+		const data = { value: 'interpolated' };
+		const interpolated = interpolate(node, data);
+		expect(interpolated.properties.test[0]).toEqual('interpolated');
+	});
+
+	it("should handle nodes without data", () => {
+		const node = {
+			properties: {
+				test: '${value}',
+			},
+		};
+		const data = { value: 'interpolated' };
+		const interpolated = interpolate(node, data);
+		expect(interpolated.properties.test).toEqual('interpolated');
+	});
+
+	describe("getMaskedData()", () => {
+
+		it("should return masked data from ancestors", () => {
+			const node = { data: { interp: { test: 'value' } } };
+			const ancestors = [{ data: { interp: { parentValue: 'parent' } } }];
+			const maskedData = __testExports.getMaskedData(node, ancestors);
+			expect(maskedData.interp).toEqual({ parentValue: 'parent', test: 'value' });
+		});
+	});
+
+	// interpolateNode() tests
+	describe("interpolateNode()", () => {
+		it("should interpolate node properties", () => {
+			const node = {
+				properties: {
+					test: '${value}',
+				},
+				data: {
+					interp: {
+						value: 'interpolated',
+					},
+				},
+			};
+			const ancestors = [];
+			const interpolatedNode = __testExports.interpolateNode(node, ancestors);
+			expect(interpolatedNode.properties.test).toEqual('interpolated');
+		});
+
+		it("should interpolate node properties that are not strings or arrays", () => {
+			const node = {
+				properties: {
+					prop: 45, // Corrected property name
+				},
+				data: {},
+			};
+			const ancestors = [];
+			const interpolatedNode = __testExports.interpolateNode(node, ancestors);
+			expect(interpolatedNode.properties.prop).toEqual('45');
+		});
+	});
+
+	describe("interpolateString()", () => {
+
+		it("should interpolate string with data", () => {
+			const str = '${value}';
+			const data = { value: 'interpolated' };
+			const interpolatedStr = __testExports.interpolateString(str, data);
+			expect(interpolatedStr).toEqual('interpolated');
+		});
+
+		it("should throw on an undefined variable", () => {
+			expect(() => __testExports.interpolateString("${f}", {})).toThrow();
+			expect(() => __testExports.interpolateString("${f||'foo'}", {})).toThrow();
+		});
+
+	});
+});
 describe("interpolate()", () => {
 
 	it("should import", () => {