uss-xsd-engine 0.1.0 → 0.1.1

package/dist/uss-xsd-engine.esm.js

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.1.0
+ * uss-xsd-engine v0.1.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -1575,6 +1575,111 @@ function isImportNamespaceCompatible(ref, importedSchema) {
   }
   return (declaredNs || null) === (importedNs || null);
 }
+function normalizeSchemaPath(value) {
+  if (!value || typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function getSchemaPathBasename(value) {
+  const normalized = normalizeSchemaPath(value);
+  if (!normalized) return null;
+  const parts = normalized.split("/");
+  return parts[parts.length - 1] || null;
+}
+function getExternalDocumentEntries(externalDocuments) {
+  return Object.entries(externalDocuments || {}).map(([key, text]) => ({
+    key,
+    normalizedKey: normalizeSchemaPath(key),
+    basename: getSchemaPathBasename(key),
+    text
+  }));
+}
+function getDeclaredTargetNamespaceFromText(xsdText) {
+  if (typeof xsdText !== "string" || !xsdText.trim()) {
+    return null;
+  }
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(xsdText, "application/xml");
+    const parserError = doc.querySelector("parsererror");
+    if (parserError) return null;
+    const root = getSchemaRoot(doc);
+    if (!root) return null;
+    return root.hasAttribute("targetNamespace") ? root.getAttribute("targetNamespace") : null;
+  } catch {
+    return null;
+  }
+}
+function resolveExternalDocument(ref, externalDocuments) {
+  const entries = getExternalDocumentEntries(externalDocuments);
+  const requestedLocation = ref?.schemaLocation || null;
+  const normalizedRequestedLocation = normalizeSchemaPath(requestedLocation);
+  const requestedBasename = getSchemaPathBasename(requestedLocation);
+  if (requestedLocation && Object.prototype.hasOwnProperty.call(externalDocuments, requestedLocation)) {
+    return {
+      kind: "exact",
+      entry: {
+        key: requestedLocation,
+        normalizedKey: normalizedRequestedLocation,
+        basename: requestedBasename,
+        text: externalDocuments[requestedLocation]
+      },
+      matches: []
+    };
+  }
+  if (normalizedRequestedLocation) {
+    const normalizedMatches = entries.filter(
+      (entry) => entry.normalizedKey === normalizedRequestedLocation
+    );
+    if (normalizedMatches.length === 1) {
+      return {
+        kind: "normalized",
+        entry: normalizedMatches[0],
+        matches: normalizedMatches
+      };
+    }
+  }
+  if (requestedBasename) {
+    const basenameMatches = entries.filter(
+      (entry) => entry.basename === requestedBasename
+    );
+    if (basenameMatches.length === 1) {
+      return {
+        kind: "basename",
+        entry: basenameMatches[0],
+        matches: basenameMatches
+      };
+    }
+  }
+  if (ref?.kind === "import" && ref.namespace) {
+    const namespaceMatches = entries.filter((entry) => {
+      const declaredTargetNamespace = getDeclaredTargetNamespaceFromText(
+        entry.text
+      );
+      return (declaredTargetNamespace || null) === (ref.namespace || null);
+    });
+    if (namespaceMatches.length === 1) {
+      return {
+        kind: "namespace",
+        entry: namespaceMatches[0],
+        matches: namespaceMatches
+      };
+    }
+    if (namespaceMatches.length > 1) {
+      return {
+        kind: "ambiguous-namespace",
+        entry: null,
+        matches: namespaceMatches
+      };
+    }
+  }
+  return {
+    kind: "not-found",
+    entry: null,
+    matches: []
+  };
+}
 function buildSchemaModel(doc, options = {}) {
   const issues = [];
   const schema = createEmptySchemaModel();
@@ -1773,11 +1878,34 @@ function buildSchemaModel(doc, options = {}) {
   const imports = schema.externalRefs.imports || [];
   for (const ref of [...includes, ...imports]) {
     if (!ref.schemaLocation) continue;
-    const visitKey = ref.kind === "include" && schema.targetNamespace ? `${ref.schemaLocation}::include::${schema.targetNamespace}` : ref.schemaLocation;
+    const resolution = resolveExternalDocument(ref, externalDocuments);
+    if (resolution.kind === "ambiguous-namespace") {
+      issues.push(
+        createIssue({
+          code: ISSUE_CODES.XSD_IMPORT_NOT_PROVIDED,
+          severity: "error",
+          message: `Multiple provided schemas match xs:import namespace '${ref.namespace || ""}'. Unable to determine which schema to use.`,
+          line: ref.line,
+          column: ref.column,
+          path: ref.path,
+          source: "xsd",
+          nodeKind: ref.kind,
+          details: {
+            schemaLocation: ref.schemaLocation,
+            namespace: ref.namespace,
+            matchingKeys: resolution.matches.map((match) => match.key)
+          }
+        })
+      );
+      continue;
+    }
+    const resolvedEntry = resolution.entry;
+    const resolvedSchemaKey = resolvedEntry?.key || ref.schemaLocation;
+    const visitKey = ref.kind === "include" && schema.targetNamespace ? `${resolvedSchemaKey}::include::${schema.targetNamespace}` : resolvedSchemaKey;
     if (visited.has(visitKey)) {
       continue;
     }
-    const externalXsdText = externalDocuments[ref.schemaLocation];
+    const externalXsdText = resolvedEntry?.text || null;
     if (!externalXsdText) {
       issues.push(
         createIssue({
@@ -1820,9 +1948,6 @@ function buildSchemaModel(doc, options = {}) {
       ...shouldApplyChameleonInclude ? { _overrideTargetNamespace: schema.targetNamespace } : {}
     });
     if (externalBuild.schema) {
-      if (ref.kind === "import") {
-        schema.importedSchemas.push(externalBuild.schema);
-      }
       if (ref.kind === "include") {
         if (!isIncludeNamespaceCompatible(schema, externalBuild.schema)) {
           issues.push(
@@ -1837,6 +1962,8 @@ function buildSchemaModel(doc, options = {}) {
               nodeKind: "include",
               details: {
                 schemaLocation: ref.schemaLocation,
+                resolvedSchemaKey,
+                resolutionKind: resolution.kind,
                 hostTargetNamespace: schema.targetNamespace || null,
                 includedTargetNamespace: externalBuild.schema.targetNamespace || null,
                 includedDeclaredTargetNamespace: externalDeclaredTargetNamespace,
@@ -1866,6 +1993,8 @@ function buildSchemaModel(doc, options = {}) {
               nodeKind: "import",
               details: {
                 schemaLocation: ref.schemaLocation,
+                resolvedSchemaKey,
+                resolutionKind: resolution.kind,
                 declaredNamespace: ref.namespace || null,
                 importedTargetNamespace: externalBuild.schema.targetNamespace || null
               }
@@ -2204,12 +2333,72 @@ function runDefaultFixedDiagnostics(schema) {
 }
 
 // src/diagnostics/schemaImportDiagnostics.js
+function normalizeSchemaPath2(value) {
+  if (!value || typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed.replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+function getSchemaPathBasename2(value) {
+  const normalized = normalizeSchemaPath2(value);
+  if (!normalized) return null;
+  const parts = normalized.split("/");
+  return parts[parts.length - 1] || null;
+}
+function getExternalDocumentEntries2(externalDocuments) {
+  return Object.entries(externalDocuments || {}).map(([key, text]) => ({
+    key,
+    normalizedKey: normalizeSchemaPath2(key),
+    basename: getSchemaPathBasename2(key),
+    text
+  }));
+}
+function getDeclaredTargetNamespaceFromText2(xsdText) {
+  if (typeof xsdText !== "string" || !xsdText.trim()) {
+    return null;
+  }
+  try {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(xsdText, "application/xml");
+    const parserError = doc.querySelector("parsererror");
+    if (parserError) return null;
+    const root = doc?.documentElement || null;
+    if (!root || root.localName !== "schema") return null;
+    return root.hasAttribute("targetNamespace") ? root.getAttribute("targetNamespace") : null;
+  } catch {
+    return null;
+  }
+}
+function hasMatchingExternalDocument(ref, externalDocuments) {
+  const entries = getExternalDocumentEntries2(externalDocuments);
+  const requestedLocation = ref?.schemaLocation || null;
+  const normalizedRequestedLocation = normalizeSchemaPath2(requestedLocation);
+  const requestedBasename = getSchemaPathBasename2(requestedLocation);
+  if (requestedLocation && Object.prototype.hasOwnProperty.call(externalDocuments, requestedLocation)) {
+    return true;
+  }
+  if (normalizedRequestedLocation && entries.some((entry) => entry.normalizedKey === normalizedRequestedLocation)) {
+    return true;
+  }
+  if (requestedBasename && entries.some((entry) => entry.basename === requestedBasename)) {
+    return true;
+  }
+  if (ref?.kind === "import" && ref.namespace) {
+    return entries.some((entry) => {
+      const declaredTargetNamespace = getDeclaredTargetNamespaceFromText2(
+        entry.text
+      );
+      return (declaredTargetNamespace || null) === (ref.namespace || null);
+    });
+  }
+  return false;
+}
 function runImportDiagnostics(schema, options = {}) {
   const issues = [];
   const externalDocuments = options.externalDocuments || {};
   for (const ref of schema.externalRefs.includes || []) {
     if (!ref.schemaLocation) continue;
-    if (externalDocuments[ref.schemaLocation]) continue;
+    if (hasMatchingExternalDocument(ref, externalDocuments)) continue;
     issues.push(
       createIssue({
         code: ISSUE_CODES.XSD_INCLUDE_NOT_PROVIDED,
@@ -2229,7 +2418,7 @@ function runImportDiagnostics(schema, options = {}) {
   }
   for (const ref of schema.externalRefs.imports || []) {
     if (!ref.schemaLocation) continue;
-    if (externalDocuments[ref.schemaLocation]) continue;
+    if (hasMatchingExternalDocument(ref, externalDocuments)) continue;
     issues.push(
       createIssue({
         code: ISSUE_CODES.XSD_IMPORT_NOT_PROVIDED,
@@ -2440,7 +2629,7 @@ function runSchemaDiagnostics(schema, options = {}) {
 }
 
 // src/version.js
-var ENGINE_VERSION = "v0.1.0";
+var ENGINE_VERSION = "v0.1.1";
 
 // src/utils/result.js
 function summarizeIssues(issues = []) {

package/dist/uss-xsd-engine.standalone.js

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.1.0
+ * uss-xsd-engine v0.1.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -1602,6 +1602,111 @@ var UssXsdEngine = (() => {
     }
     return (declaredNs || null) === (importedNs || null);
   }
+  function normalizeSchemaPath(value) {
+    if (!value || typeof value !== "string") return null;
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    return trimmed.replace(/\\/g, "/").replace(/\/+/g, "/");
+  }
+  function getSchemaPathBasename(value) {
+    const normalized = normalizeSchemaPath(value);
+    if (!normalized) return null;
+    const parts = normalized.split("/");
+    return parts[parts.length - 1] || null;
+  }
+  function getExternalDocumentEntries(externalDocuments) {
+    return Object.entries(externalDocuments || {}).map(([key, text]) => ({
+      key,
+      normalizedKey: normalizeSchemaPath(key),
+      basename: getSchemaPathBasename(key),
+      text
+    }));
+  }
+  function getDeclaredTargetNamespaceFromText(xsdText) {
+    if (typeof xsdText !== "string" || !xsdText.trim()) {
+      return null;
+    }
+    try {
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(xsdText, "application/xml");
+      const parserError = doc.querySelector("parsererror");
+      if (parserError) return null;
+      const root = getSchemaRoot(doc);
+      if (!root) return null;
+      return root.hasAttribute("targetNamespace") ? root.getAttribute("targetNamespace") : null;
+    } catch {
+      return null;
+    }
+  }
+  function resolveExternalDocument(ref, externalDocuments) {
+    const entries = getExternalDocumentEntries(externalDocuments);
+    const requestedLocation = ref?.schemaLocation || null;
+    const normalizedRequestedLocation = normalizeSchemaPath(requestedLocation);
+    const requestedBasename = getSchemaPathBasename(requestedLocation);
+    if (requestedLocation && Object.prototype.hasOwnProperty.call(externalDocuments, requestedLocation)) {
+      return {
+        kind: "exact",
+        entry: {
+          key: requestedLocation,
+          normalizedKey: normalizedRequestedLocation,
+          basename: requestedBasename,
+          text: externalDocuments[requestedLocation]
+        },
+        matches: []
+      };
+    }
+    if (normalizedRequestedLocation) {
+      const normalizedMatches = entries.filter(
+        (entry) => entry.normalizedKey === normalizedRequestedLocation
+      );
+      if (normalizedMatches.length === 1) {
+        return {
+          kind: "normalized",
+          entry: normalizedMatches[0],
+          matches: normalizedMatches
+        };
+      }
+    }
+    if (requestedBasename) {
+      const basenameMatches = entries.filter(
+        (entry) => entry.basename === requestedBasename
+      );
+      if (basenameMatches.length === 1) {
+        return {
+          kind: "basename",
+          entry: basenameMatches[0],
+          matches: basenameMatches
+        };
+      }
+    }
+    if (ref?.kind === "import" && ref.namespace) {
+      const namespaceMatches = entries.filter((entry) => {
+        const declaredTargetNamespace = getDeclaredTargetNamespaceFromText(
+          entry.text
+        );
+        return (declaredTargetNamespace || null) === (ref.namespace || null);
+      });
+      if (namespaceMatches.length === 1) {
+        return {
+          kind: "namespace",
+          entry: namespaceMatches[0],
+          matches: namespaceMatches
+        };
+      }
+      if (namespaceMatches.length > 1) {
+        return {
+          kind: "ambiguous-namespace",
+          entry: null,
+          matches: namespaceMatches
+        };
+      }
+    }
+    return {
+      kind: "not-found",
+      entry: null,
+      matches: []
+    };
+  }
   function buildSchemaModel(doc, options = {}) {
     const issues = [];
     const schema = createEmptySchemaModel();
@@ -1800,11 +1905,34 @@ var UssXsdEngine = (() => {
     const imports = schema.externalRefs.imports || [];
     for (const ref of [...includes, ...imports]) {
       if (!ref.schemaLocation) continue;
-      const visitKey = ref.kind === "include" && schema.targetNamespace ? `${ref.schemaLocation}::include::${schema.targetNamespace}` : ref.schemaLocation;
+      const resolution = resolveExternalDocument(ref, externalDocuments);
+      if (resolution.kind === "ambiguous-namespace") {
+        issues.push(
+          createIssue({
+            code: ISSUE_CODES.XSD_IMPORT_NOT_PROVIDED,
+            severity: "error",
+            message: `Multiple provided schemas match xs:import namespace '${ref.namespace || ""}'. Unable to determine which schema to use.`,
+            line: ref.line,
+            column: ref.column,
+            path: ref.path,
+            source: "xsd",
+            nodeKind: ref.kind,
+            details: {
+              schemaLocation: ref.schemaLocation,
+              namespace: ref.namespace,
+              matchingKeys: resolution.matches.map((match) => match.key)
+            }
+          })
+        );
+        continue;
+      }
+      const resolvedEntry = resolution.entry;
+      const resolvedSchemaKey = resolvedEntry?.key || ref.schemaLocation;
+      const visitKey = ref.kind === "include" && schema.targetNamespace ? `${resolvedSchemaKey}::include::${schema.targetNamespace}` : resolvedSchemaKey;
       if (visited.has(visitKey)) {
         continue;
       }
-      const externalXsdText = externalDocuments[ref.schemaLocation];
+      const externalXsdText = resolvedEntry?.text || null;
       if (!externalXsdText) {
         issues.push(
           createIssue({
@@ -1847,9 +1975,6 @@ var UssXsdEngine = (() => {
         ...shouldApplyChameleonInclude ? { _overrideTargetNamespace: schema.targetNamespace } : {}
       });
       if (externalBuild.schema) {
-        if (ref.kind === "import") {
-          schema.importedSchemas.push(externalBuild.schema);
-        }
         if (ref.kind === "include") {
           if (!isIncludeNamespaceCompatible(schema, externalBuild.schema)) {
             issues.push(
@@ -1864,6 +1989,8 @@ var UssXsdEngine = (() => {
                 nodeKind: "include",
                 details: {
                   schemaLocation: ref.schemaLocation,
+                  resolvedSchemaKey,
+                  resolutionKind: resolution.kind,
                   hostTargetNamespace: schema.targetNamespace || null,
                   includedTargetNamespace: externalBuild.schema.targetNamespace || null,
                   includedDeclaredTargetNamespace: externalDeclaredTargetNamespace,
@@ -1893,6 +2020,8 @@ var UssXsdEngine = (() => {
                 nodeKind: "import",
                 details: {
                   schemaLocation: ref.schemaLocation,
+                  resolvedSchemaKey,
+                  resolutionKind: resolution.kind,
                   declaredNamespace: ref.namespace || null,
                   importedTargetNamespace: externalBuild.schema.targetNamespace || null
                 }
@@ -2231,12 +2360,72 @@ var UssXsdEngine = (() => {
   }
 
   // src/diagnostics/schemaImportDiagnostics.js
+  function normalizeSchemaPath2(value) {
+    if (!value || typeof value !== "string") return null;
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    return trimmed.replace(/\\/g, "/").replace(/\/+/g, "/");
+  }
+  function getSchemaPathBasename2(value) {
+    const normalized = normalizeSchemaPath2(value);
+    if (!normalized) return null;
+    const parts = normalized.split("/");
+    return parts[parts.length - 1] || null;
+  }
+  function getExternalDocumentEntries2(externalDocuments) {
+    return Object.entries(externalDocuments || {}).map(([key, text]) => ({
+      key,
+      normalizedKey: normalizeSchemaPath2(key),
+      basename: getSchemaPathBasename2(key),
+      text
+    }));
+  }
+  function getDeclaredTargetNamespaceFromText2(xsdText) {
+    if (typeof xsdText !== "string" || !xsdText.trim()) {
+      return null;
+    }
+    try {
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(xsdText, "application/xml");
+      const parserError = doc.querySelector("parsererror");
+      if (parserError) return null;
+      const root = doc?.documentElement || null;
+      if (!root || root.localName !== "schema") return null;
+      return root.hasAttribute("targetNamespace") ? root.getAttribute("targetNamespace") : null;
+    } catch {
+      return null;
+    }
+  }
+  function hasMatchingExternalDocument(ref, externalDocuments) {
+    const entries = getExternalDocumentEntries2(externalDocuments);
+    const requestedLocation = ref?.schemaLocation || null;
+    const normalizedRequestedLocation = normalizeSchemaPath2(requestedLocation);
+    const requestedBasename = getSchemaPathBasename2(requestedLocation);
+    if (requestedLocation && Object.prototype.hasOwnProperty.call(externalDocuments, requestedLocation)) {
+      return true;
+    }
+    if (normalizedRequestedLocation && entries.some((entry) => entry.normalizedKey === normalizedRequestedLocation)) {
+      return true;
+    }
+    if (requestedBasename && entries.some((entry) => entry.basename === requestedBasename)) {
+      return true;
+    }
+    if (ref?.kind === "import" && ref.namespace) {
+      return entries.some((entry) => {
+        const declaredTargetNamespace = getDeclaredTargetNamespaceFromText2(
+          entry.text
+        );
+        return (declaredTargetNamespace || null) === (ref.namespace || null);
+      });
+    }
+    return false;
+  }
   function runImportDiagnostics(schema, options = {}) {
     const issues = [];
     const externalDocuments = options.externalDocuments || {};
     for (const ref of schema.externalRefs.includes || []) {
       if (!ref.schemaLocation) continue;
-      if (externalDocuments[ref.schemaLocation]) continue;
+      if (hasMatchingExternalDocument(ref, externalDocuments)) continue;
       issues.push(
         createIssue({
           code: ISSUE_CODES.XSD_INCLUDE_NOT_PROVIDED,
@@ -2256,7 +2445,7 @@ var UssXsdEngine = (() => {
     }
     for (const ref of schema.externalRefs.imports || []) {
       if (!ref.schemaLocation) continue;
-      if (externalDocuments[ref.schemaLocation]) continue;
+      if (hasMatchingExternalDocument(ref, externalDocuments)) continue;
       issues.push(
         createIssue({
           code: ISSUE_CODES.XSD_IMPORT_NOT_PROVIDED,
@@ -2467,7 +2656,7 @@ var UssXsdEngine = (() => {
   }
 
   // src/version.js
-  var ENGINE_VERSION = "v0.1.0";
+  var ENGINE_VERSION = "v0.1.1";
 
   // src/utils/result.js
   function summarizeIssues(issues = []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uss-xsd-engine",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Browser-first XSD engine for schema diagnostics, tree extraction, sample XML generation, and XML validation.",
   "type": "module",
   "main": "dist/uss-xsd-engine.esm.js",