@hyperjump/json-schema 0.18.2 → 0.18.5

package/dist/json-schema-system.js

@@ -61,8 +61,14 @@ System.register('JsonSchema', [], (function (exports) {
       (function (root, factory){
 
           var PubSub = {};
-          root.PubSub = PubSub;
-          factory(PubSub);
+
+          if (root.PubSub) {
+              PubSub = root.PubSub;
+              console.warn("PubSub already loaded, using existing version");
+          } else {
+              root.PubSub = PubSub;
+              factory(PubSub);
+          }
           // CommonJS and Node.js module support
           {
               if (module !== undefined && module.exports) {
@@ -645,7 +651,70 @@ System.register('JsonSchema', [], (function (exports) {
         return resolvedUrl;
       };
 
-      var common$1 = { jsonTypeOf: jsonTypeOf$2, splitUrl: splitUrl$4, safeResolveUrl: safeResolveUrl$1 };
+      const CHAR_BACKWARD_SLASH = 47;
+
+      const pathRelative$1 = (from, to) => {
+        if (from === to) {
+          return "";
+        }
+
+        let toStart = 1;
+        const fromLen = from.length - 1;
+        const toLen = to.length - toStart;
+
+        // Compare paths to find the longest common path from root
+        const length = fromLen < toLen ? fromLen : toLen;
+        let lastCommonSep = -1;
+        let i = 0;
+        for (; i < length; i++) {
+          const fromCode = from.charCodeAt(i + 1);
+          if (fromCode !== to.charCodeAt(toStart + i)) {
+            break;
+          } else if (fromCode === CHAR_BACKWARD_SLASH) {
+            lastCommonSep = i;
+          }
+        }
+
+        if (toLen > length) {
+          if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+            return to.slice(toStart + i + 1);
+          }
+          if (i === 0) {
+            return to.slice(toStart + i);
+          }
+        }
+        if (fromLen > length) {
+          if (from.charCodeAt(i + 1) === CHAR_BACKWARD_SLASH) {
+            lastCommonSep = i;
+          } else if (length === 0) {
+            lastCommonSep = 0;
+          }
+        }
+
+        let out = "";
+        // Generate the relative path based on the path difference between `to` and `from`
+        for (i = lastCommonSep + 2; i <= from.length; ++i) {
+          if (i === from.length || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+            out += out.length === 0 ? ".." : "/..";
+          }
+        }
+
+        toStart += lastCommonSep;
+
+        // Lastly, append the rest of the destination (`to`) path that comes after
+        // the common path parts
+        if (out.length > 0) {
+          return `${out}${to.slice(toStart, to.length)}`;
+        }
+
+        if (to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+          ++toStart;
+        }
+
+        return to.slice(toStart, to.length);
+      };
+
+      var common$1 = { jsonTypeOf: jsonTypeOf$2, splitUrl: splitUrl$4, safeResolveUrl: safeResolveUrl$1, pathRelative: pathRelative$1 };
 
       const nil$2 = "";
 
@@ -798,6 +867,10 @@ System.register('JsonSchema', [], (function (exports) {
       const value$2 = (ref) => ref[$__value];
 
       var reference = { cons: cons$1, isReference, href, value: value$2 };
+      reference.cons;
+      reference.isReference;
+      reference.href;
+      reference.value;
 
       const { jsonTypeOf: jsonTypeOf$1 } = common$1;
 
@@ -1147,7 +1220,7 @@ System.register('JsonSchema', [], (function (exports) {
 
       var fetch_browser = fetch;
 
-      const { jsonTypeOf, splitUrl: splitUrl$3, safeResolveUrl } = common$1;
+      const { jsonTypeOf, splitUrl: splitUrl$3, safeResolveUrl, pathRelative } = common$1;
 
 
 
@@ -1377,10 +1450,73 @@ System.register('JsonSchema', [], (function (exports) {
 
       const length = (doc) => value(doc).length;
 
+      const toSchemaDefaultOptions = {
+        parentId: "",
+        parentDialect: "",
+        includeEmbedded: true
+      };
+      const toSchema = (schemaDoc, options = {}) => {
+        const fullOptions = { ...toSchemaDefaultOptions, ...options };
+
+        const schema = JSON.parse(JSON.stringify(schemaDoc.schema, (key, value) => {
+          if (!reference.isReference(value)) {
+            return value;
+          }
+
+          const refValue = reference.value(value);
+          const embeddedDialect = refValue.$schema || schemaDoc.schemaVersion;
+          const embeddedToken = getConfig(embeddedDialect, "embeddedToken");
+          if (!fullOptions.includeEmbedded && embeddedToken in refValue) {
+            return;
+          } else {
+            return reference.value(value);
+          }
+        }));
+
+        const dynamicAnchorToken = getConfig(schemaDoc.schemaVersion, "dynamicAnchorToken");
+        Object.entries(schemaDoc.dynamicAnchors)
+          .forEach(([anchor, uri]) => {
+            const pointer = splitUrl$3(uri)[1];
+            lib$3.assign(pointer, schema, {
+              [dynamicAnchorToken]: anchor,
+              ...lib$3.get(pointer, schema)
+            });
+          });
+
+        const anchorToken = getConfig(schemaDoc.schemaVersion, "anchorToken");
+        Object.entries(schemaDoc.anchors)
+          .filter(([anchor]) => anchor !== "")
+          .forEach(([anchor, pointer]) => {
+            lib$3.assign(pointer, schema, {
+              [anchorToken]: anchor,
+              ...lib$3.get(pointer, schema)
+            });
+          });
+
+        const baseToken = getConfig(schemaDoc.schemaVersion, "baseToken");
+        const id = relativeUri(fullOptions.parentId, schemaDoc.id);
+        const dialect = fullOptions.parentDialect === schemaDoc.schemaVersion ? "" : schemaDoc.schemaVersion;
+        return {
+          ...(id && { [baseToken]: id }),
+          ...(dialect && { $schema: dialect }),
+          ...schema
+        };
+      };
+
+      const relativeUri = (from, to) => {
+        if (to.startsWith("file://")) {
+          const pathToSchema = from.slice(7, from.lastIndexOf("/"));
+          return from === "" ? "" : pathRelative(pathToSchema, to.slice(7));
+        } else {
+          return to;
+        }
+      };
+
       var schema$5 = {
         setConfig, getConfig,
         add: add$1, get, markValidated,
-        uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length
+        uri, value, getAnchorPointer, typeOf, has, step, keys, entries, map, length,
+        toSchema
       };
       schema$5.setConfig;
       schema$5.getConfig;
@@ -1397,6 +1533,7 @@ System.register('JsonSchema', [], (function (exports) {
       schema$5.entries;
       schema$5.map;
       schema$5.length;
+      schema$5.toSchema;
 
       class InvalidSchemaError$1 extends Error {
         constructor(output) {
@@ -1725,7 +1862,7 @@ System.register('JsonSchema', [], (function (exports) {
       keywords$1.metaData;
       keywords$1.validate;
 
-      var lib$1 = { Core: core$2, Schema: schema$5, Instance: instance, Keywords: keywords$1, InvalidSchemaError: invalidSchemaError };
+      var lib$1 = { Core: core$2, Schema: schema$5, Instance: instance, Reference: reference, Keywords: keywords$1, InvalidSchemaError: invalidSchemaError };
 
       const { Core: Core$v, Schema: Schema$N, Instance: Instance$B } = lib$1;