@workglow/util 0.2.20 → 0.2.22

package/dist/schema-entry.js

@@ -6,10 +6,171 @@ var FromSchemaDefaultOptions = {
   references: false,
   deserialize: false
 };
+// src/json-schema/SchemaValidation.ts
+import { compileSchema } from "@sroussey/json-schema-library";
+var VALID_RESULT = Object.freeze({
+  valid: true,
+  errors: Object.freeze([])
+});
+var FORMAT_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z0-9][a-zA-Z0-9_-]*)*$/;
+var VALID_JSON_SCHEMA_TYPES = new Set([
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+function validateDataPortSchema(schema) {
+  if (typeof schema === "boolean") {
+    return VALID_RESULT;
+  }
+  const errors = [];
+  if (typeof schema !== "object" || schema === null) {
+    return { valid: false, errors: [{ path: "", message: "Schema must be a boolean or object" }] };
+  }
+  if (schema.type !== "object") {
+    errors.push({
+      path: "/type",
+      message: `DataPortSchema must have type "object", got "${String(schema.type)}"`
+    });
+  }
+  if (!schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
+    errors.push({
+      path: "/properties",
+      message: "DataPortSchema must have a properties object"
+    });
+  } else {
+    for (const [key, value] of Object.entries(schema.properties)) {
+      if (typeof value === "boolean") {
+        errors.push({
+          path: `/properties/${key}`,
+          message: `Property "${key}" must not be a boolean schema`
+        });
+        continue;
+      }
+      collectJsonSchemaErrors(value, `/properties/${key}`, errors);
+    }
+  }
+  return errors.length === 0 ? VALID_RESULT : { valid: false, errors };
+}
+function collectJsonSchemaErrors(schema, path, errors) {
+  if (typeof schema === "boolean") {
+    return;
+  }
+  if (schema === null || schema === undefined) {
+    errors.push({ path, message: `Expected schema object, got ${typeof schema}` });
+    return;
+  }
+  if (typeof schema !== "object") {
+    errors.push({ path, message: `Expected schema object, got ${typeof schema}` });
+    return;
+  }
+  if (schema.type !== undefined) {
+    if (typeof schema.type === "string") {
+      if (!VALID_JSON_SCHEMA_TYPES.has(schema.type)) {
+        errors.push({
+          path: `${path}/type`,
+          message: `Unknown JSON Schema type "${schema.type}"`
+        });
+      }
+    } else if (Array.isArray(schema.type)) {
+      for (const t of schema.type) {
+        if (!VALID_JSON_SCHEMA_TYPES.has(t)) {
+          errors.push({
+            path: `${path}/type`,
+            message: `Unknown JSON Schema type "${String(t)}" in type array`
+          });
+        }
+      }
+    }
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    for (const [key, value] of Object.entries(schema.properties)) {
+      if (typeof value === "boolean") {
+        continue;
+      }
+      collectJsonSchemaErrors(value, `${path}/properties/${key}`, errors);
+    }
+  }
+  if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+    collectJsonSchemaErrors(schema.items, `${path}/items`, errors);
+  }
+  if (Array.isArray(schema.items)) {
+    for (let i = 0;i < schema.items.length; i++) {
+      collectJsonSchemaErrors(schema.items[i], `${path}/items/${i}`, errors);
+    }
+  }
+  for (const keyword of ["oneOf", "anyOf", "allOf"]) {
+    const arr = schema[keyword];
+    if (Array.isArray(arr)) {
+      for (let i = 0;i < arr.length; i++) {
+        collectJsonSchemaErrors(arr[i], `${path}/${keyword}/${i}`, errors);
+      }
+    }
+  }
+}
+function validateFormatAnnotations(schema) {
+  if (typeof schema === "boolean") {
+    return VALID_RESULT;
+  }
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "Schema must be a JSON Schema object or boolean" }]
+    };
+  }
+  const errors = [];
+  collectFormatErrors(schema, "", errors);
+  return errors.length === 0 ? VALID_RESULT : { valid: false, errors };
+}
+function collectFormatErrors(schema, path, errors) {
+  if (typeof schema !== "object" || schema === null) {
+    return;
+  }
+  const format = schema.format;
+  if (typeof format === "string" && !FORMAT_PATTERN.test(format)) {
+    errors.push({
+      path: `${path}/format`,
+      message: `Invalid format annotation "${format}" — must match pattern ${FORMAT_PATTERN.source}`
+    });
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    for (const [key, value] of Object.entries(schema.properties)) {
+      collectFormatErrors(value, `${path}/properties/${key}`, errors);
+    }
+  }
+  if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+    collectFormatErrors(schema.items, `${path}/items`, errors);
+  }
+  if (Array.isArray(schema.items)) {
+    for (let i = 0;i < schema.items.length; i++) {
+      collectFormatErrors(schema.items[i], `${path}/items/${i}`, errors);
+    }
+  }
+  for (const keyword of ["oneOf", "anyOf", "allOf"]) {
+    const arr = schema[keyword];
+    if (Array.isArray(arr)) {
+      for (let i = 0;i < arr.length; i++) {
+        collectFormatErrors(arr[i], `${path}/${keyword}/${i}`, errors);
+      }
+    }
+  }
+}
+function validateSchema(schema) {
+  if (typeof schema === "boolean") {
+    return VALID_RESULT;
+  }
+  const structureResult = validateDataPortSchema(schema);
+  const formatResult = validateFormatAnnotations(schema);
+  const allErrors = [...structureResult.errors, ...formatResult.errors];
+  return allErrors.length === 0 ? VALID_RESULT : { valid: false, errors: allErrors };
+}
+
 // src/json-schema/SchemaUtils.ts
 function areFormatStringsCompatible(sourceFormat, targetFormat) {
-  const formatPattern = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)?$/;
-  if (!formatPattern.test(sourceFormat) || !formatPattern.test(targetFormat)) {
+  if (!FORMAT_PATTERN.test(sourceFormat) || !FORMAT_PATTERN.test(targetFormat)) {
     return "incompatible";
   }
   const [sourceName, sourceNarrow] = sourceFormat.split(":");
@@ -353,167 +514,6 @@ function areSemanticallyCompatible(sourceSchema, targetSchema) {
 function areObjectSchemasSemanticallyCompatible(sourceSchema, targetSchema) {
   return areSemanticallyCompatible(sourceSchema, targetSchema);
 }
-// src/json-schema/SchemaValidation.ts
-import { compileSchema } from "@sroussey/json-schema-library";
-var VALID_RESULT = Object.freeze({
-  valid: true,
-  errors: Object.freeze([])
-});
-var FORMAT_PATTERN = /^[a-zA-Z][a-zA-Z0-9_-]*(?::[a-zA-Z][a-zA-Z0-9_-]*)?$/;
-var VALID_JSON_SCHEMA_TYPES = new Set([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "object",
-  "array",
-  "null"
-]);
-function validateDataPortSchema(schema) {
-  if (typeof schema === "boolean") {
-    return VALID_RESULT;
-  }
-  const errors = [];
-  if (typeof schema !== "object" || schema === null) {
-    return { valid: false, errors: [{ path: "", message: "Schema must be a boolean or object" }] };
-  }
-  if (schema.type !== "object") {
-    errors.push({
-      path: "/type",
-      message: `DataPortSchema must have type "object", got "${String(schema.type)}"`
-    });
-  }
-  if (!schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
-    errors.push({
-      path: "/properties",
-      message: "DataPortSchema must have a properties object"
-    });
-  } else {
-    for (const [key, value] of Object.entries(schema.properties)) {
-      if (typeof value === "boolean") {
-        errors.push({
-          path: `/properties/${key}`,
-          message: `Property "${key}" must not be a boolean schema`
-        });
-        continue;
-      }
-      collectJsonSchemaErrors(value, `/properties/${key}`, errors);
-    }
-  }
-  return errors.length === 0 ? VALID_RESULT : { valid: false, errors };
-}
-function collectJsonSchemaErrors(schema, path, errors) {
-  if (typeof schema === "boolean") {
-    return;
-  }
-  if (schema === null || schema === undefined) {
-    errors.push({ path, message: `Expected schema object, got ${typeof schema}` });
-    return;
-  }
-  if (typeof schema !== "object") {
-    errors.push({ path, message: `Expected schema object, got ${typeof schema}` });
-    return;
-  }
-  if (schema.type !== undefined) {
-    if (typeof schema.type === "string") {
-      if (!VALID_JSON_SCHEMA_TYPES.has(schema.type)) {
-        errors.push({
-          path: `${path}/type`,
-          message: `Unknown JSON Schema type "${schema.type}"`
-        });
-      }
-    } else if (Array.isArray(schema.type)) {
-      for (const t of schema.type) {
-        if (!VALID_JSON_SCHEMA_TYPES.has(t)) {
-          errors.push({
-            path: `${path}/type`,
-            message: `Unknown JSON Schema type "${String(t)}" in type array`
-          });
-        }
-      }
-    }
-  }
-  if (schema.properties && typeof schema.properties === "object") {
-    for (const [key, value] of Object.entries(schema.properties)) {
-      if (typeof value === "boolean") {
-        continue;
-      }
-      collectJsonSchemaErrors(value, `${path}/properties/${key}`, errors);
-    }
-  }
-  if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
-    collectJsonSchemaErrors(schema.items, `${path}/items`, errors);
-  }
-  if (Array.isArray(schema.items)) {
-    for (let i = 0;i < schema.items.length; i++) {
-      collectJsonSchemaErrors(schema.items[i], `${path}/items/${i}`, errors);
-    }
-  }
-  for (const keyword of ["oneOf", "anyOf", "allOf"]) {
-    const arr = schema[keyword];
-    if (Array.isArray(arr)) {
-      for (let i = 0;i < arr.length; i++) {
-        collectJsonSchemaErrors(arr[i], `${path}/${keyword}/${i}`, errors);
-      }
-    }
-  }
-}
-function validateFormatAnnotations(schema) {
-  if (typeof schema === "boolean") {
-    return VALID_RESULT;
-  }
-  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
-    return {
-      valid: false,
-      errors: [{ path: "", message: "Schema must be a JSON Schema object or boolean" }]
-    };
-  }
-  const errors = [];
-  collectFormatErrors(schema, "", errors);
-  return errors.length === 0 ? VALID_RESULT : { valid: false, errors };
-}
-function collectFormatErrors(schema, path, errors) {
-  if (typeof schema !== "object" || schema === null) {
-    return;
-  }
-  const format = schema.format;
-  if (typeof format === "string" && !FORMAT_PATTERN.test(format)) {
-    errors.push({
-      path: `${path}/format`,
-      message: `Invalid format annotation "${format}" — must match pattern ${FORMAT_PATTERN.source}`
-    });
-  }
-  if (schema.properties && typeof schema.properties === "object") {
-    for (const [key, value] of Object.entries(schema.properties)) {
-      collectFormatErrors(value, `${path}/properties/${key}`, errors);
-    }
-  }
-  if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
-    collectFormatErrors(schema.items, `${path}/items`, errors);
-  }
-  if (Array.isArray(schema.items)) {
-    for (let i = 0;i < schema.items.length; i++) {
-      collectFormatErrors(schema.items[i], `${path}/items/${i}`, errors);
-    }
-  }
-  for (const keyword of ["oneOf", "anyOf", "allOf"]) {
-    const arr = schema[keyword];
-    if (Array.isArray(arr)) {
-      for (let i = 0;i < arr.length; i++) {
-        collectFormatErrors(arr[i], `${path}/${keyword}/${i}`, errors);
-      }
-    }
-  }
-}
-function validateSchema(schema) {
-  if (typeof schema === "boolean") {
-    return VALID_RESULT;
-  }
-  const structureResult = validateDataPortSchema(schema);
-  const formatResult = validateFormatAnnotations(schema);
-  const allErrors = [...structureResult.errors, ...formatResult.errors];
-  return allErrors.length === 0 ? VALID_RESULT : { valid: false, errors: allErrors };
-}
 // src/json-schema/parsePartialJson.ts
 function parsePartialJson(text) {
   const trimmed = text.trim();
@@ -925,7 +925,8 @@ export {
   TypedArraySchema,
   TensorType,
   TensorSchema,
-  FromSchemaDefaultOptions
+  FromSchemaDefaultOptions,
+  FORMAT_PATTERN
 };
 
-//# debugId=3151F1BBE117DDD664756E2164756E21
+//# debugId=A6ECA6928852238264756E2164756E21