Additional refactoring and expose functions for extension

Author: jdesrosiers

eslint.config.js

@@ -5,8 +5,8 @@ import importPlugin from "eslint-plugin-import";
 export default tseslint.config(
   ...tseslint.configs.recommendedTypeChecked,
   ...tseslint.configs.stylisticTypeChecked,
-  importPlugin.flatConfigs.recommended, // eslint-disable-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
-  importPlugin.flatConfigs.typescript, // eslint-disable-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+  importPlugin.flatConfigs.recommended,
+  importPlugin.flatConfigs.typescript,
   stylistic.configs.customize({
     arrowParens: true,
     braceStyle: "1tbs",
@@ -36,6 +36,7 @@ export default tseslint.config(
       }],
       "@typescript-eslint/no-empty-function": "off",
       "@typescript-eslint/consistent-type-definitions": ["error", "type"],
+      "@typescript-eslint/consistent-indexed-object-style": "off",
       "no-console": "error",
 
       // Imports

src/errorHandlers/additionalProperties.js renamed to src/error-handlers/additionalProperties.js

@@ -1,19 +1,18 @@
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
+
 /** @type ErrorHandler */
-const additionalProperties = async (normalizedErrors, instance, language) => {
+// eslint-disable-next-line @typescript-eslint/require-await
+const additionalProperties = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
   if (normalizedErrors["https://json-schema.org/validation"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/validation"]) {
       if (!normalizedErrors["https://json-schema.org/validation"][schemaLocation] && schemaLocation.endsWith("/additionalProperties")) {
-        const notAllowedValue = /** @type string */(Instance.uri(instance).split("/").pop());
-        const localization = await Localization.forLocale(language);
+        const notAllowedValue = /** @type string */ (Instance.uri(instance).split("/").pop());
         errors.push({
           message: localization.getAdditionalPropertiesErrorMessage(notAllowedValue),
           instanceLocation: Instance.uri(instance),

src/errorHandlers/anyOf.js renamed to src/error-handlers/anyOf.js

@@ -1,17 +1,14 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { getErrors } from "../utilis.js";
-import { Localization } from "../localization.js";
+import { getErrors } from "../error-handling.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import { NormalizedOutput } from "../normalizeOutputFormat/normalizeOutput.js"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject, NormalizedOutput } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const anyOf = async (normalizedErrors, instance, language) => {
+const anyOf = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -29,7 +26,6 @@ const anyOf = async (normalizedErrors, instance, language) => {
       if (alternatives.length === 0) {
         /** @type Set<string> */
         const expectedTypes = new Set();
-        const localization = await Localization.forLocale(language);
         for (const alternative of allAlternatives) {
           for (const instanceLocation in alternative) {
             if (instanceLocation === Instance.uri(instance)) {
@@ -47,14 +43,14 @@ const anyOf = async (normalizedErrors, instance, language) => {
           schemaLocation: schemaLocation
         });
       } else if (alternatives.length === 1) { // case 2 when only one type match
-        return getErrors(alternatives[0], instance, language);
+        return getErrors(alternatives[0], instance, localization);
       } else if (instance.type === "object") {
         let targetAlternativeIndex = -1;
         for (const alternative of alternatives) {
           targetAlternativeIndex++;
           for (const instanceLocation in alternative) {
             if (instanceLocation !== "#") {
-              return getErrors(alternatives[targetAlternativeIndex], instance, language);
+              return getErrors(alternatives[targetAlternativeIndex], instance, localization);
             }
           }
         }

src/errorHandlers/const.js renamed to src/error-handlers/const.js

@@ -1,23 +1,20 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const const_ = async (normalizedErrors, instance, language) => {
+const const_ = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
   if (normalizedErrors["https://json-schema.org/keyword/const"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/const"]) {
       if (!normalizedErrors["https://json-schema.org/keyword/const"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
-        const localization = await Localization.forLocale(language);
         errors.push({
           message: localization.getConstErrorMessage(Schema.value(keyword)),
           instanceLocation: Instance.uri(instance),

src/errorHandlers/contains.js renamed to src/error-handlers/contains.js

@@ -1,27 +1,24 @@
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { getErrors } from "../utilis.js";
-import { Localization } from "../localization.js";
+import { getErrors } from "../error-handling.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import { NormalizedOutput } from "../normalizeOutputFormat/normalizeOutput.js"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject, NormalizedOutput } from "../index.d.ts"
  */
+
 /** @type ErrorHandler */
-const contains = async (normalizedErrors, instance, language) => {
+const contains = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
   if (normalizedErrors["https://json-schema.org/keyword/contains"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/contains"]) {
-      const localization = await Localization.forLocale(language);
       errors.push({
         message: localization.getContainsErrorMessage(),
         instanceLocation: Instance.uri(instance),
         schemaLocation: schemaLocation
       });
       const containsNodes = /** @type NormalizedOutput[] */(normalizedErrors["https://json-schema.org/keyword/contains"][schemaLocation]);
       for (const errorOutput of containsNodes) {
-        const containsSubErrors = await getErrors(errorOutput, instance, language);
+        const containsSubErrors = await getErrors(errorOutput, instance, localization);
         errors.push(...containsSubErrors);
       }
     }

src/errorHandlers/dependentRequired.js renamed to src/error-handlers/dependentRequired.js

@@ -1,15 +1,13 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const dependentRequired = async (normalizedErrors, instance, language) => {
+const dependentRequired = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -18,7 +16,6 @@ const dependentRequired = async (normalizedErrors, instance, language) => {
       if (!normalizedErrors["https://json-schema.org/keyword/dependentRequired"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
         const dependentRequired = /** @type {Record<string, string[]>} */(Schema.value(keyword));
-        const localization = await Localization.forLocale(language);
         for (const propertyName in dependentRequired) {
           if (Instance.has(propertyName, instance)) {
             const required = dependentRequired[propertyName];

src/errorHandlers/enum.js renamed to src/error-handlers/enum.js

@@ -2,23 +2,20 @@ import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
 import leven from "leven";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const enum_ = async (normalizedErrors, instance, language) => {
+const enum_ = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
   if (normalizedErrors["https://json-schema.org/keyword/enum"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/enum"]) {
       if (!normalizedErrors["https://json-schema.org/keyword/enum"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
-        const localization = await Localization.forLocale(language);
 
         /** @type {Array<string>} */
         const allowedValues = Schema.value(keyword);

src/errorHandlers/exclusiveMaximum.js renamed to src/error-handlers/exclusiveMaximum.js

@@ -1,22 +1,20 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
+
 /** @type ErrorHandler */
-const exclusiveMaximum = async (normalizedErrors, instance, language) => {
+const exclusiveMaximum = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
   if (normalizedErrors["https://json-schema.org/keyword/exclusiveMaximum"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/exclusiveMaximum"]) {
       if (!normalizedErrors["https://json-schema.org/keyword/exclusiveMaximum"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
-        const localization = await Localization.forLocale(language);
         errors.push({
           message: localization.getExclusiveMaximumErrorMessage(Schema.value(keyword)),
           instanceLocation: Instance.uri(instance),

src/errorHandlers/exclusiveMinimum.js renamed to src/error-handlers/exclusiveMinimum.js

@@ -1,23 +1,20 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const exclusiveMinimum = async (normalizedErrors, instance, language) => {
+const exclusiveMinimum = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
   if (normalizedErrors["https://json-schema.org/keyword/exclusiveMinimum"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/exclusiveMinimum"]) {
       if (!normalizedErrors["https://json-schema.org/keyword/exclusiveMinimum"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
-        const localization = await Localization.forLocale(language);
         errors.push({
           message: localization.getExclusiveMinimumErrorMessage(Schema.value(keyword)),
           instanceLocation: Instance.uri(instance),

src/errorHandlers/format.js renamed to src/error-handlers/format.js

@@ -1,23 +1,20 @@
 import { getSchema } from "@hyperjump/json-schema/experimental";
 import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
-import { Localization } from "../localization.js";
 
 /**
- * @import {ErrorObject } from "../index.d.ts"
- * @import {ErrorHandler} from "../utilis.js"
+ * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const format = async (normalizedErrors, instance, language) => {
+const format = async (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 
   if (normalizedErrors["https://json-schema.org/keyword/format"]) {
     for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/format"]) {
       if (!normalizedErrors["https://json-schema.org/keyword/format"][schemaLocation]) {
         const keyword = await getSchema(schemaLocation);
-        const localization = await Localization.forLocale(language);
         errors.push({
           message: localization.getFormatErrorMessage(Schema.value(keyword)),
           instanceLocation: Instance.uri(instance),