orc-scripts 4.0.0-dev.9 → 4.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orc-scripts",
-  "version": "4.0.0-dev.9",
+  "version": "4.0.1",
   "description": "Scripts toolbox for Orckestra",
   "type": "commonjs",
   "bin": {

package/src/config/eslint.config.mjs

@@ -1,45 +1,64 @@
 import globals from "globals";
+import pluginJs from "@eslint/js";
 import pluginReactConfig from "eslint-plugin-react/configs/recommended.js";
-import pluginReactHookConfig from "eslint-plugin-react-hooks"
+import pluginReactHookConfig from "eslint-plugin-react-hooks";
 
 export default [
-  { files: ["**/*.{js,mjs,cjs,jsx}"] },
-  { languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } } },
-  { files: ["**/*.js"], languageOptions: { sourceType: "module" } },
-  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
-  pluginReactConfig,
-  {
-    plugins: {
-      "react-hooks": pluginReactHookConfig,
-    },
-    rules: pluginReactHookConfig.configs.recommended.rules,
-  },
-  {
-    files: ["**/*.test.js"],
-    rules: {
-      "react/jsx-key": "off",
-    }
-  },
-  {
-    "settings": {
-      "react": {
-        "version": "detect"
-      }
-    },
-    languageOptions: {
-      globals: {
-        SUPPORTED_LOCALES: false,
-        OVERTURE_APPLICATION: false,
-        DEPENDENCIES: false,
-        BUILD_ID: false,
-        BUILD_NUMBER: false,
-      },
-    },
-    rules: {
-      "jsx-a11y/href-no-hash": "off",
-      "react/prop-types": "off",
-      "react/no-children-prop": "off",
-      "react/display-name": "off",
-    }
-  }
-];
+	{ files: ["**/*.{js,mjs,cjs,jsx}"] },
+	{ languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } } },
+	{ files: ["**/*.js"], languageOptions: { sourceType: "module" } },
+	{ languageOptions: { globals: { ...globals.browser, ...globals.node, ...{ Intl: false } } } },
+	pluginJs.configs.recommended,
+	pluginReactConfig,
+	{
+		plugins: {
+			"react-hooks": pluginReactHookConfig,
+		},
+		rules: pluginReactHookConfig.configs.recommended.rules,
+	},
+	{
+		files: ["**/*.test.js"],
+		languageOptions: { globals: { ...globals.jest } },
+		rules: {
+			"react/jsx-key": "off",
+		},
+	},
+	{
+		files: ["**/*.js"],
+		rules: {
+			"no-unused-vars": [
+				"error",
+				{
+					vars: "all",
+					args: "none",
+					caughtErrors: "all",
+					ignoreRestSiblings: false,
+				},
+			],
+		},
+	},
+	{
+		settings: {
+			react: {
+				version: "detect",
+			},
+		},
+		languageOptions: {
+			globals: {
+				SUPPORTED_LOCALES: false,
+				OVERTURE_APPLICATION: false,
+				DEPENDENCIES: false,
+				BUILD_ID: false,
+				BUILD_NUMBER: false,
+			},
+		},
+		rules: {
+			"jsx-a11y/href-no-hash": "off",
+			"react/prop-types": "off",
+			"react/no-children-prop": "off",
+			"react/display-name": "off",
+			"no-mixed-spaces-and-tabs": "off",
+			"no-case-declarations": "off",
+		},
+	},
+];

package/src/config/unexpected-form.js

@@ -91,7 +91,7 @@ module.exports = {
 				type: "Combination",
 				fields: expect.it("to be an array").and("to have items satisfying", "to be a form field"),
 			};
-			if (subject.hasOwnProperty("proportions")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "proportions")) {
 				pattern.proportions = expect
 					.it("to be an array")
 					.and("to have items satisfying", expect.it("to be a string").or("to be a number"))
@@ -109,17 +109,17 @@ module.exports = {
 				name: expect.it("to be a string"),
 				rowField: expect.it("to be a form field").or("to be a form combination field"),
 			};
-			if (subject.hasOwnProperty("rowCount")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "rowCount")) {
 				pattern.rowCount = expect.it("to be a number");
 			}
-			if (subject.hasOwnProperty("add")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "add")) {
 				if (subject.rowCount) {
 					expect.errorMode = "nested";
 					return expect.fail("Form list with row count cannot have 'add' label");
 				}
 				pattern.add = expect.it("to be a label");
 			}
-			if (subject.hasOwnProperty("staticValues")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "staticValues")) {
 				if (!subject.rowCount) {
 					expect.errorMode = "nested";
 					return expect.fail("Form list without row count cannot have static values");
@@ -173,135 +173,135 @@ module.exports = {
 };
 
 const addLabelProp = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("label")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "label")) {
 		pattern.label = expect.it("to be a label");
 	}
 };
 
 const addMultipleProp = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("multiple")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "multiple")) {
 		pattern.multiple = expect.it("to be a boolean");
 	}
 };
 
 const addButtonProps = (expect, subject, pattern, small) => {
-	if (subject.hasOwnProperty("primary")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "primary")) {
 		pattern.primary = expect.it("to be a boolean");
 	}
-	if (subject.hasOwnProperty("active")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "active")) {
 		pattern.active = expect.it("to be a boolean");
 	}
 	if (small) {
 		pattern.altText = expect.it("to be a label");
 		pattern.icon = expect.it("to be a string");
 	} else {
-		if (subject.hasOwnProperty("buttonText")) {
+		if (Object.prototype.hasOwnProperty.call(subject, "buttonText")) {
 			pattern.buttonText = expect.it("to be a label");
 		}
-		if (subject.hasOwnProperty("icon")) {
+		if (Object.prototype.hasOwnProperty.call(subject, "icon")) {
 			pattern.icon = expect.it("to be a string");
 		}
 	}
-	if (subject.hasOwnProperty("autofocus")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "autofocus")) {
 		pattern.autofocus = expect.it("to be a boolean");
 	}
-	if (subject.hasOwnProperty("disabled")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "disabled")) {
 		pattern.disabled = expect.it("to be a boolean");
 	}
 };
 
 const addInputProps = (expect, subject, pattern, textual = true) => {
-	if (textual && subject.hasOwnProperty("autocomplete")) {
+	if (textual && Object.prototype.hasOwnProperty.call(subject, "autocomplete")) {
 		pattern.autocomplete = expect.it("to be a string");
 	}
-	if (subject.hasOwnProperty("autofocus")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "autofocus")) {
 		pattern.autofocus = expect.it("to be a boolean");
 	}
-	if (subject.hasOwnProperty("disabled")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "disabled")) {
 		pattern.disabled = expect.it("to be a boolean");
 	}
-	if (textual && subject.hasOwnProperty("readOnly")) {
+	if (textual && Object.prototype.hasOwnProperty.call(subject, "readOnly")) {
 		pattern.readOnly = expect.it("to be a boolean");
 	}
-	if (subject.hasOwnProperty("required")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "required")) {
 		pattern.required = expect.it("to be a label");
 	}
-	if (subject.hasOwnProperty("tabindex")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "tabindex")) {
 		pattern.tabindex = expect.it("to be a number");
 	}
 };
 
 const addTextInputProps = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("maxlength")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "maxlength")) {
 		pattern.maxlength = expect.it("to be a number").and("to be greater than", 0);
 	}
-	if (subject.hasOwnProperty("minlength")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "minlength")) {
 		pattern.minlength = expect.it("to be a number").and("to be greater than", 0);
 	}
-	if (subject.hasOwnProperty("pattern")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "pattern")) {
 		pattern.pattern = expect.it("to be a regular expression");
 	}
-	if (subject.hasOwnProperty("placeholder")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "placeholder")) {
 		pattern.placeholder = expect.it("to be a label");
 	}
-	if (subject.hasOwnProperty("size")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "size")) {
 		pattern.size = expect.it("to be a number").and("to be greater than", 0);
 	}
-	if (subject.hasOwnProperty("spellcheck")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "spellcheck")) {
 		pattern.spellcheck = expect.it("to be a boolean").or("to be", "");
 	}
 };
 
 const addNumberInputProps = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("max")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "max")) {
 		pattern.max = expect.it("to be a number");
 	}
-	if (subject.hasOwnProperty("min")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "min")) {
 		pattern.min = expect.it("to be a number");
 	}
-	if (subject.hasOwnProperty("step")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "step")) {
 		pattern.step = expect.it("to be a number");
 	}
-	if (subject.hasOwnProperty("placeholder")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "placeholder")) {
 		pattern.placeholder = expect.it("to be a label");
 	}
 };
 
 const addDateInputProps = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("max")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "max")) {
 		pattern.max = expect.it("to be a string").and("to match", /^\d{4}-\d{2}-\d{2}$/);
 	}
-	if (subject.hasOwnProperty("min")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "min")) {
 		pattern.min = expect.it("to be a string").and("to match", /^\d{4}-\d{2}-\d{2}$/);
 	}
-	if (subject.hasOwnProperty("step")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "step")) {
 		pattern.step = expect.it("to be a number");
 	}
 };
 
 const addTimeInputProps = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("max")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "max")) {
 		pattern.max = expect.it("to be a string").and("to match", /^\d{2}:\d{2}(?::\d{2})?$/);
 	}
-	if (subject.hasOwnProperty("min")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "min")) {
 		pattern.min = expect.it("to be a string").and("to match", /^\d{2}:\d{2}(?::\d{2})?$/);
 	}
-	if (subject.hasOwnProperty("step")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "step")) {
 		pattern.step = expect.it("to be a number").or("to be", "any");
 	}
 };
 
 const addSwitchInputProps = (expect, subject, pattern) => {
-	if (subject.hasOwnProperty("onCaption")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "onCaption")) {
 		pattern.onCaption = expect.it("to be a label");
 	}
-	if (subject.hasOwnProperty("offCaption")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "offCaption")) {
 		pattern.offCaption = expect.it("to be a label");
 	}
-	if (subject.hasOwnProperty("onColor")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "onColor")) {
 		pattern.onColor = expect.it("to be a string");
 	}
-	if (subject.hasOwnProperty("offColor")) {
+	if (Object.prototype.hasOwnProperty.call(subject, "offColor")) {
 		pattern.offColor = expect.it("to be a string");
 	}
 };

package/src/config/unexpected.js

@@ -69,10 +69,10 @@ global.expect = unexpected
 					.or("to be an array")
 					.and("to have items satisfying", expect.it("to be a string").or("to be a number")),
 			};
-			if (subject.hasOwnProperty("width")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "width")) {
 				pattern.width = expect.it("to be a string").and("not to match", /[;:{[]/);
 			}
-			if (subject.hasOwnProperty("type")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "type")) {
 				pattern.type = expect
 					.it("to be", "number")
 					.or("to be", "date")
@@ -87,26 +87,26 @@ global.expect = unexpected
 						.or("to be an array")
 						.and("to have items satisfying", "to be a string");
 				}
-				if (subject.type === "switch" && subject.hasOwnProperty("switch")) {
+				if (subject.type === "switch" && Object.prototype.hasOwnProperty.call(subject, "switch")) {
 					pattern.switch = expect.it("to be an object");
 				}
 				if (subject.type === "custom") {
 					pattern.component = expect.it("to be a function");
-					if (subject.hasOwnProperty("funcs")) {
+					if (Object.prototype.hasOwnProperty.call(subject, "funcs")) {
 						pattern.funcs = expect.it("to have values satisfying", "to be a function");
 					}
 				}
 			}
-			if (subject.hasOwnProperty("transform")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "transform")) {
 				pattern.transform = expect.it("to be a function");
 			}
-			if (subject.hasOwnProperty("label")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "label")) {
 				pattern.label = expect.it("to be a label");
 			}
-			if (subject.hasOwnProperty("sort")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "sort")) {
 				pattern.sort = expect.it("to be a function");
 			}
-			if (subject.hasOwnProperty("defaultValue")) {
+			if (Object.prototype.hasOwnProperty.call(subject, "defaultValue")) {
 				pattern.defaultValue = expect.it("to be defined");
 			}
 			return expect(subject, "to exhaustively satisfy", pattern);

package/src/index.js

@@ -7,7 +7,7 @@ global.amOrcScripts = /orc-scripts$/.test(require("pkg-dir").sync() || "");
 let shouldThrow;
 try {
 	shouldThrow = Number(process.version.slice(1).split(".")[0]) < 10;
-} catch (error) {
+} catch {
 	// ignore
 }
 

package/src/run-script.js

@@ -76,7 +76,7 @@ function spawnScript() {
 function attemptResolve(...resolveArgs) {
 	try {
 		return require.resolve(...resolveArgs);
-	} catch (error) {
+	} catch {
 		return null;
 	}
 }

package/src/scripts/buildDep.js

@@ -65,7 +65,9 @@ async function build(repos) {
 
 		try {
 			await makeDir("builds");
-		} catch (_) {}
+		} catch {
+			// don't do anything
+		}
 
 		const releaseArgs = ["--branch", releaseBranch, "--single-branch"];
 

package/src/scripts/prep.js

@@ -20,7 +20,9 @@ async function prep() {
 			copyFile(contentDir, path.resolve(distDir, "content")),
 			copyFile(mockDir, path.resolve(distDir, "__mocks__")),
 		]);
-	} catch (_) {}
+	} catch {
+		// don't do anything
+	}
 
 	if (process.env.NODE_ENV === "production") {
 		// production build will not copy the static files
@@ -28,7 +30,9 @@ async function prep() {
 		try {
 			const files = await readdir(staticDir);
 			await Promise.all(files.map(file => copyFile(path.resolve(staticDir, file), path.resolve(distDir, file))));
-		} catch (_) {}
+		} catch {
+			// don't do anything
+		}
 	}
 
 	if (existsSync(projectSpecificPrep)) {

package/src/utils.js

@@ -4,7 +4,8 @@ const arrify = require("arrify");
 const which = require("which");
 const readPkgUp = require("read-pkg-up");
 
-const hasOwn = (obj, key) => obj.hasOwnProperty(key) && obj[key] !== null && obj[key] !== undefined;
+const hasOwn = (obj, key) =>
+	Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== null && obj[key] !== undefined;
 
 const hasPath = (obj, keys) => {
 	const [key, ...tail] = keys;
@@ -46,7 +47,7 @@ function parseEnv(name, def) {
 	if (envIsSet(name)) {
 		try {
 			return JSON.parse(process.env[name] || "<fail>");
-		} catch (err) {
+		} catch {
 			return process.env[name];
 		}
 	}
@@ -54,14 +55,16 @@ function parseEnv(name, def) {
 }
 
 function envIsSet(name) {
-	return process.env.hasOwnProperty(name) && process.env[name] && process.env[name] !== "undefined";
+	return (
+		Object.prototype.hasOwnProperty.call(process.env, name) && process.env[name] && process.env[name] !== "undefined"
+	);
 }
 
 function resolveBin(modName, { executable = modName, cwd = process.cwd() } = {}) {
 	let pathFromWhich;
 	try {
 		pathFromWhich = fs.realpathSync(which.sync(executable));
-	} catch (_error) {
+	} catch {
 		// ignore _error
 	}
 	try {