@flourish/sdk 5.2.0 → 5.2.2

package/skeleton/package.json

@@ -18,5 +18,9 @@
     "rollup": "^1.16.2",
     "rollup-plugin-node-resolve": "^5.1.0",
     "rollup-plugin-uglify": "^6.0.2"
+  },
+  "engines": {
+    "node": "20.19.x",
+    "npm": "10.8.2"
   }
 }

package/test/lib/sdk.js

@@ -4,7 +4,6 @@ const assert = require("assert"),
 
 const { readConfig, readAndValidateConfig } = require("../../lib/sdk.js");
 
-
 describe("readConfig", () => {
 	before(async function() {
 		const { temporaryDirectory } = await import("tempy");

package/test/lib/validate_config.js

@@ -45,11 +45,11 @@ describe("validate_config", function() {
 	}
 
 	function bindingPlus(o) {
-		return metadataPlus({ data: [ Object.assign({}, binding, o) ] });
+		return metadataPlus({ data: [Object.assign({}, binding, o)] });
 	}
 
 	function settingPlus(o, other, more_settings=[]) {
-		return metadataPlus(Object.assign({ settings: [ Object.assign({}, setting_foo, o), setting_bar ].concat(more_settings) }, other));
+		return metadataPlus(Object.assign({ settings: [Object.assign({}, setting_foo, o), setting_bar].concat(more_settings) }, other));
 	}
 
 	function testBoolean(name) {
@@ -325,30 +325,30 @@ describe("validate_config", function() {
 				"template.yml: “build.foo.files” must be an array");
 		});
 		it("should reject a null file", function() {
-			expectFailure(metadataPlus({ build: { foo: { script: "", files: [ null ] } } }),
+			expectFailure(metadataPlus({ build: { foo: { script: "", files: [null] } } }),
 				"template.yml: the entries of “build.foo.files” must be strings");
 		});
 		it("should reject an undefined file", function() {
-			expectFailure(metadataPlus({ build: { foo: { script: "", files: [ undefined ] } } }),
+			expectFailure(metadataPlus({ build: { foo: { script: "", files: [undefined] } } }),
 				"template.yml: the entries of “build.foo.files” must be strings");
 		});
 		it("should reject a numeric file", function() {
-			expectFailure(metadataPlus({ build: { foo: { script: "", files: [ 23 ] } } }),
+			expectFailure(metadataPlus({ build: { foo: { script: "", files: [23] } } }),
 				"template.yml: the entries of “build.foo.files” must be strings");
 		});
 		it("should reject a true file", function() {
-			expectFailure(metadataPlus({ build: { foo: { script: "", files: [ true ] } } }),
+			expectFailure(metadataPlus({ build: { foo: { script: "", files: [true] } } }),
 				"template.yml: the entries of “build.foo.files” must be strings");
 		});
 		it("should reject a false file", function() {
-			expectFailure(metadataPlus({ build: { foo: { script: "", files: [ false ] } } }),
+			expectFailure(metadataPlus({ build: { foo: { script: "", files: [false] } } }),
 				"template.yml: the entries of “build.foo.files” must be strings");
 		});
 		it("should accept a string file", function() {
-			expectSuccess(metadataPlus({ build: { foo: { script: "", files: [ "" ] } } }));
+			expectSuccess(metadataPlus({ build: { foo: { script: "", files: [""] } } }));
 		});
 		it("should accept two strings", function() {
-			expectSuccess(metadataPlus({ build: { foo: { script: "", files: [ "one", "two" ] } } }));
+			expectSuccess(metadataPlus({ build: { foo: { script: "", files: ["one", "two"] } } }));
 		});
 
 		it("should reject a null directory", function() {
@@ -410,23 +410,23 @@ describe("validate_config", function() {
 		      type = binding.type;
 
 		it("should require name", function() {
-			expectFailure(metadataPlus({ data: [ { dataset, key, type } ] }),
+			expectFailure(metadataPlus({ data: [{ dataset, key, type }] }),
 				"template.yml data binding must specify a name");
 		});
 		it("should require dataset", function() {
-			expectFailure(metadataPlus({ data: [ { name, key, type } ] }),
+			expectFailure(metadataPlus({ data: [{ name, key, type }] }),
 				"template.yml data binding “My binding” must specify a dataset");
 		});
 		it("should require key", function() {
-			expectFailure(metadataPlus({ data: [ { name, dataset, type } ] }),
+			expectFailure(metadataPlus({ data: [{ name, dataset, type }] }),
 				"template.yml data binding “My binding” must specify a key");
 		});
 		it("should require type", function() {
-			expectFailure(metadataPlus({ data: [ { name, dataset, key } ] }),
+			expectFailure(metadataPlus({ data: [{ name, dataset, key }] }),
 				"template.yml data binding “My binding” must specify a type");
 		});
 		it("should require column for non-optional column bindings", function() {
-			expectFailure(metadataPlus({ data: [ { name, dataset, key, type } ] }),
+			expectFailure(metadataPlus({ data: [{ name, dataset, key, type }] }),
 				"template.yml non-optional data binding “My binding” must specify column");
 		});
 		it("should accept name/dataset/key/type=column/column", function() {
@@ -528,17 +528,17 @@ describe("validate_config", function() {
 			expectSuccess(bindingPlus({ optional: false }));
 		});
 		it("should require column if optional is false", function() {
-			expectFailure(metadataPlus({ data: [ { name, dataset, key, type, optional: false } ] }),
+			expectFailure(metadataPlus({ data: [{ name, dataset, key, type, optional: false }] }),
 				"template.yml non-optional data binding “My binding” must specify column");
 		});
 
 		it("should reject duplicates", function() {
-			expectFailure(metadataPlus({ data: [ binding, binding ] }),
+			expectFailure(metadataPlus({ data: [binding, binding] }),
 				"template.yml: there is more than one data binding with dataset “dataset” and key “key”");
 		});
 
 		it("should ignore headings", function() {
-			expectSuccess(metadataPlus({ data: [ "Heading", binding ] }));
+			expectSuccess(metadataPlus({ data: ["Heading", binding] }));
 		});
 	});
 
@@ -571,19 +571,19 @@ describe("validate_config", function() {
 		});
 
 		it("should require property", function() {
-			expectFailure(metadataPlus({ settings: [ { name: "Foo", type: "string" } ] }),
+			expectFailure(metadataPlus({ settings: [{ name: "Foo", type: "string" }] }),
 				"template.yml setting must specify a property:");
 		});
 		it("should require type", function() {
-			expectFailure(metadataPlus({ settings: [ { name: "Foo", property: "foo" } ] }),
+			expectFailure(metadataPlus({ settings: [{ name: "Foo", property: "foo" }] }),
 				"template.yml setting “foo” must specify a type:");
 		});
 		it("should require name", function() {
-			expectFailure(metadataPlus({ settings: [ { property: "foo", type: "string" } ] }),
+			expectFailure(metadataPlus({ settings: [{ property: "foo", type: "string" }] }),
 				"template.yml setting “foo” must specify a name:");
 		});
 		it("should not require name if choices are specified", function() {
-			expectSuccess(metadataPlus({ settings: [ { property: "foo", type: "string", choices: [] } ] }));
+			expectSuccess(metadataPlus({ settings: [{ property: "foo", type: "string", choices: [] }] }));
 		});
 
 		describe("optional settings", function() {
@@ -828,43 +828,43 @@ describe("validate_config", function() {
 
 			it("should accept an array containing an object with multiple string values", function() {
 				const blah = { name: "Blah", property: "blah", type: "string" };
-				expectSuccess(settingPlus({ show_if: [ { "bar": "xxx", "blah": "xxx" }] }, undefined, [blah]));
+				expectSuccess(settingPlus({ show_if: [{ "bar": "xxx", "blah": "xxx" }] }, undefined, [blah]));
 			});
 
 			it("should accept an array containing an object with multiple array values", function() {
 				const blah = { name: "Blah", property: "blah", type: "string" };
-				expectSuccess(settingPlus({ show_if: [ { "bar": ["xxx"], "blah": ["xxx"] }] }, undefined, [blah]));
+				expectSuccess(settingPlus({ show_if: [{ "bar": ["xxx"], "blah": ["xxx"] }] }, undefined, [blah]));
 			});
 
 			it("should reject an array containing any objects with empty array values", function() {
 				const blah = { name: "Blah", property: "blah", type: "string" };
-				expectFailure(settingPlus({ show_if: [ { "bar": [], "blah": "xxx" }] }, undefined, [blah]),
+				expectFailure(settingPlus({ show_if: [{ "bar": [], "blah": "xxx" }] }, undefined, [blah]),
 					"template.yml setting “foo” “show_if” property: condition for bar is empty");
 			});
 
 			it("should reject an array containing any objects referring to non-existent settings", function() {
-				expectFailure(settingPlus({ show_if: [ { "bar": "xxx", "baz": "xxx" }] }),
+				expectFailure(settingPlus({ show_if: [{ "bar": "xxx", "baz": "xxx" }] }),
 					"template.yml: “show_if” or “hide_if” property refers to non-existent setting “baz”");
 			});
 
 			it("should accept an array containing an object with a string value and a valid data binding", function() {
-				expectSuccess(settingPlus({ show_if: [ { "bar": "xxx", "data.dataset.key": true }] }, { data: [ binding ] }));
+				expectSuccess(settingPlus({ show_if: [{ "bar": "xxx", "data.dataset.key": true }] }, { data: [binding] }));
 			});
 
 			it("should reject an array with a data reference when there are no data bindings", function() {
-				expectFailure(settingPlus({ show_if: [ { "bar": "xxx", "data.dataset.key": true }] }),
+				expectFailure(settingPlus({ show_if: [{ "bar": "xxx", "data.dataset.key": true }] }),
 					"template.yml: “show_if” or “hide_if” property refers to data binding “data.dataset.key” when none are defined");
 			});
 
 			it("should reject an array with a reference to a non-existent data binding", function() {
-				expectFailure(settingPlus({ show_if: [ { "bar": "xxx", "data.dataset.nosuchkey": true }] }, { data: [ binding ] }),
+				expectFailure(settingPlus({ show_if: [{ "bar": "xxx", "data.dataset.nosuchkey": true }] }, { data: [binding] }),
 					"template.yml: “show_if” or “hide_if” property refers to non-existent data binding “data.dataset.nosuchkey”");
 			});
 
 			it("should accept an array containing multiple objects of including string and boolean values", function() {
 				const blah = { name: "Blah", property: "blah", type: "string" };
 				const bool = { name: "Bool", property: "bool", type: "boolean" };
-				expectSuccess(settingPlus({ show_if: [ { "bar": "xxx", "blah": "xxx" }, { "bool": true }] }, undefined, [blah, bool]));
+				expectSuccess(settingPlus({ show_if: [{ "bar": "xxx", "blah": "xxx" }, { "bool": true }] }, undefined, [blah, bool]));
 			});
 
 			it("should forbid empty objects", function() {
@@ -887,26 +887,26 @@ describe("validate_config", function() {
 					"template.yml: “show_if” or “hide_if” property refers to non-existent setting “baz”");
 			});
 			it("should accept a reference to a data binding", function() {
-				expectSuccess(settingPlus({ show_if: "data.dataset.key" }, { data: [ binding ] }));
+				expectSuccess(settingPlus({ show_if: "data.dataset.key" }, { data: [binding] }));
 			});
 			it("should reject a data reference when there are no data bindings", function() {
 				expectFailure(settingPlus({ show_if: "data.dataset.key" }),
 					"template.yml: “show_if” or “hide_if” property refers to data binding “data.dataset.key” when none are defined");
 			});
 			it("should reject a reference to a non-existent data binding", function() {
-				expectFailure(settingPlus({ show_if: "data.dataset.nosuchkey" }, { data: [ binding ] }),
+				expectFailure(settingPlus({ show_if: "data.dataset.nosuchkey" }, { data: [binding] }),
 					"template.yml: “show_if” or “hide_if” property refers to non-existent data binding “data.dataset.nosuchkey”");
 			});
 
 			// This test is skipped because it doesn’t pass, and looks like it would be
 			// complicated to fix.
 			it.skip("should reject a string value when referencing a data binding", function() {
-				expectFailure(settingPlus({ show_if: { "data.dataset.key": "foo" } }, { data: [ binding ] }));
+				expectFailure(settingPlus({ show_if: { "data.dataset.key": "foo" } }, { data: [binding] }));
 			});
 
 			it("should reject a reference to a data binding that has no key", function() {
 				const binding_undef_key = { name: "No-key binding", dataset: "dataset", key: undefined, type: "column", column: "Foo::A" };
-				expectFailure(settingPlus({ show_if: "data.dataset" }, { data: [ binding_undef_key ] }),
+				expectFailure(settingPlus({ show_if: "data.dataset" }, { data: [binding_undef_key] }),
 					"template.yml: “show_if” or “hide_if” property specifies invalid data binding or column type “data.dataset”");
 			});
 			it("should accept settings whose names start with /data./ [kiln/flourish-sdk#45]", function() {

package/server/columns.js

@@ -1,201 +0,0 @@
-/* * * * * * GENERATED FILE - DO NOT EDIT * * * * * *
- * * * * * * GENERATED FILE - DO NOT EDIT * * * * * *
- * * * * * * GENERATED FILE - DO NOT EDIT * * * * * */
- 
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const MAX_INTEGER = Math.pow(2, 31) - 1;
-const MAX_RANGE_LENGTH = Math.pow(2, 15);
-
-// Attempt to parse col_spec as a columns spec;
-// return true if we succeed, and false if not.
-function looksLikeMultipleColumns(col_spec) {
-	try {
-		parseColumns(col_spec);
-	}
-	catch (e) {
-		return false;
-	}
-	return true;
-}
-
-function parseColumn(col_spec, is_optional) {
-	col_spec = col_spec.toUpperCase();
-	if (!/^[A-Z]+$/.test(col_spec)) {
-		if (!col_spec) {
-			if (is_optional) return -1; // Use -1 for unassigned optional binding
-			else throw new Error("Non-optional data binding must specify column");
-		}
-		if (looksLikeMultipleColumns(col_spec)) {
-			throw new Error("You can only select one column");
-		}
-		else throw new Error("Invalid column specification: " + col_spec);
-	}
-
-	var col_ix = 0;
-	for (var i = 0; i < col_spec.length; i++) {
-		col_ix = col_ix * 26 + (col_spec.charCodeAt(i) - 64);
-	}
-
-	if (col_ix - 1 > MAX_INTEGER) console.warn("Column index out of range");
-	return Math.min(col_ix - 1, MAX_INTEGER);
-}
-
-function printColumn(col_ix) {
-	col_ix += 1;
-	var col_spec = "";
-	while (col_ix > 0) {
-		var q = Math.floor(col_ix / 26),
-		    r = col_ix % 26;
-
-		if (r == 0) {
-			q -= 1;
-			r += 26;
-		}
-
-		col_spec = String.fromCharCode(64 + r) + col_spec;
-		col_ix = q;
-	}
-	return col_spec;
-}
-
-function parseRange(col_range) {
-	var dash_mo = col_range.match(/\s*(?:[-–—:]|\.\.)\s*/);
-	if (!dash_mo) throw new Error("Failed to parse column range: " + col_range);
-
-	var first = col_range.substr(0, dash_mo.index),
-	    last = col_range.substr(dash_mo.index + dash_mo[0].length);
-
-	var first_ix = parseColumn(first),
-	    last_ix = parseColumn(last);
-
-	var r = [];
-	var incrementer = last_ix >= first_ix ? 1 : -1;
-	var n = Math.abs(last_ix - first_ix) + 1;
-
-	if (n > MAX_RANGE_LENGTH) {
-		console.warn("Truncating excessively long range");
-		n = MAX_RANGE_LENGTH;
-	}
-
-	for (var i = 0; i < n; i++) {
-		r.push(first_ix + i*incrementer);
-	}
-
-	return r;
-}
-
-function printRange(start, end) {
-	return printColumn(start) + "-" + printColumn(end);
-}
-
-function parseColumns(cols_spec) {
-	var indexes = [];
-
-	cols_spec = cols_spec.replace(/^\s+|\s+$/g, "");
-	var split_cols = cols_spec.split(/\s*,\s*/);
-	if (split_cols.length == 1 && split_cols[0] === "") split_cols = [];
-
-	for (var i = 0; i < split_cols.length; i++) {
-		var col_or_range = split_cols[i];
-		if (/^[A-Za-z]+$/.test(col_or_range)) {
-			indexes.push(parseColumn(col_or_range));
-		}
-		else {
-			Array.prototype.push.apply(indexes, parseRange(col_or_range));
-		}
-	}
-
-	return indexes;
-}
-
-function splitIntoRanges(indexes) {
-	if (!indexes.length) {
-		return [];
-	}
-	var ranges = [];
-	var start = indexes[0], end = indexes[0];
-	var direction = null;
-	for (var i = 0; i < indexes.length - 1; i++) {
-		var diff = indexes[i + 1] - indexes[i];
-		if (direction === null && Math.abs(diff) === 1) {
-			// It's a range with either ascending columns (direction=1), or descending
-			// columns (direction=-1)
-			end = indexes[i + 1];
-			direction = diff;
-			continue;
-		}
-
-		if (diff === direction) {
-			// The range is continuing in the same direction as before
-			end = indexes[i + 1];
-			continue;
-		}
-
-		// There's nothing more in the range, so add it, and start a new range from the
-		// next column
-		ranges.push([start, end]);
-		start = end = indexes[i + 1];
-		direction = null;
-	}
-	// There will always be a range which hasn't been added at the end
-	ranges.push([start, end]);
-	return ranges;
-}
-
-function printColumns(indexes) {
-	var ranges = splitIntoRanges(indexes);
-
-	var r = [];
-	for (var i = 0; i < ranges.length; i++) {
-		var range = ranges[i];
-		if (range[0] == range[1]) r.push(printColumn(range[0]));
-		else r.push(printRange(range[0], range[1]));
-	}
-	return r.join(",");
-}
-
-function parseDataBinding(d, data_table_ids) {
-	var r = {};
-
-	if (!(d.type in d)) {
-		if (d.optional) return r;
-		throw new Error("Data binding must specify '" + d.type + "': " + JSON.stringify(d));
-	}
-
-	var double_colon_ix = d[d.type].indexOf("::");
-	if (double_colon_ix == -1) throw new Error("Invalid data binding: " + d[d.type]);
-	var data_table_name = d[d.type].substr(0, double_colon_ix);
-	r.data_table_id = data_table_ids[data_table_name];
-
-	var col_spec = d[d.type].substr(double_colon_ix + 2);
-	if (d.type == "column") r.column = parseColumn(col_spec, d.optional);
-	else if (d.type == "columns") r.columns = parseColumns(col_spec);
-	else throw new Error("Unknown data binding type: " + d.type);
-
-	return r;
-}
-
-function printDataBinding(r, data_table_names, print_data_table_name, optional) {
-	var data_table_name = print_data_table_name ? data_table_names[r.data_table_id] + "::" : "";
-	if ("column" in r) {
-		return data_table_name + printColumn(r.column);
-	}
-	else if ("columns" in r) {
-		return data_table_name + printColumns(r.columns);
-	}
-	else if (optional) {
-		return "";
-	}
-	throw new Error("Data binding must have .column or .columns");
-}
-
-exports.parseColumn = parseColumn;
-exports.parseColumns = parseColumns;
-exports.parseDataBinding = parseDataBinding;
-exports.parseRange = parseRange;
-exports.printColumn = printColumn;
-exports.printColumns = printColumns;
-exports.printDataBinding = printDataBinding;