@valbuild/react 0.91.1 → 0.91.2

package/dist/raw-d3f56a16.esm.js

@@ -0,0 +1,455 @@
+import { b as _unsupportedIterableToArray, a as _typeof, c as _arrayLikeToArray, _ as _slicedToArray } from './slicedToArray-0c0a3b4a.esm.js';
+import { Internal, VAL_EXTENSION, FILE_REF_PROP } from '@valbuild/core';
+import { vercelStegaDecodeAll, vercelStegaSplit, vercelStegaCombine } from '@vercel/stega';
+
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = !0,
+    u = !1;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = !0, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+
+function stegaDecodeStrings(encodedString) {
+  if (!encodedString || typeof encodedString !== "string") return;
+  var encodedBits = vercelStegaDecodeAll(encodedString);
+  var paths = [];
+  if (!encodedBits) return;
+  var _iterator = _createForOfIteratorHelper(encodedBits),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var encodedBit = _step.value;
+      if (encodedBit && _typeof(encodedBit) === "object") {
+        if ("origin" in encodedBit && "data" in encodedBit && _typeof(encodedBit.data) === "object" && encodedBit.data && "valPath" in encodedBit.data && typeof encodedBit.data.valPath === "string") {
+          paths.push(encodedBit.data.valPath);
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return paths.length > 0 ? paths : undefined;
+}
+
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+
+/**
+ * ValEncodedString is a string that is encoded using steganography.
+ *
+ * This means that there is a hidden / non-visible object embedded in the string.
+ * This object includes a path, which is used to automatically tag
+ * where the content comes from for contextual editing.
+ *
+ */
+
+/**
+ * RichText is accessible by users (after conversion via useVal / fetchVal)
+ **/
+
+function stegaEncode(input, opts) {
+  function rec(sourceOrSelector, recOpts) {
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isKeyOfSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
+      return sourceOrSelector;
+    }
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isLiteralSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
+      return sourceOrSelector;
+    }
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isDateSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
+      return sourceOrSelector;
+    }
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isUnionSchema(recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema)) {
+      if (sourceOrSelector && _typeof(sourceOrSelector) === "object" && recOpts.schema.key && typeof recOpts.schema.key === "string") {
+        var _key = sourceOrSelector[recOpts.schema.key];
+        if (_key) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          var schema = recOpts.schema.items.find(function (s) {
+            if (isObjectSchema(s) && s.items && s.items[recOpts.schema.key]) {
+              var keySchema = s.items[recOpts.schema.key];
+              if (isLiteralSchema(keySchema)) {
+                return keySchema.value === _key;
+              } else {
+                console.warn("Expected literal schema at key in , but found: ", keySchema, {
+                  key: _key,
+                  schema: s
+                });
+              }
+            } else {
+              console.warn("Expected union containing object schema, but found: ", s);
+            }
+          });
+          if (schema) {
+            return rec(sourceOrSelector, {
+              path: recOpts.path,
+              schema: schema
+            });
+          }
+        }
+        // illegal value, return as is
+        return sourceOrSelector;
+      }
+      if (typeof sourceOrSelector === "string" && recOpts.schema.key && typeof recOpts.schema.key !== "string") {
+        var _ref;
+        return rec(sourceOrSelector, {
+          path: recOpts.path,
+          schema: (_ref = [recOpts.schema.key]).concat.apply(_ref, _toConsumableArray(recOpts.schema.items)).find(function (s) {
+            if (isLiteralSchema(s)) {
+              return s.value === sourceOrSelector;
+            }
+          })
+        });
+      }
+    }
+    if (recOpts !== null && recOpts !== void 0 && recOpts.schema && isRichTextSchema(recOpts.schema)) {
+      if (typeof sourceOrSelector === "string") {
+        return rec(sourceOrSelector, {
+          path: recOpts.path,
+          schema: {
+            type: "string"
+          }
+        });
+      }
+      if (Array.isArray(sourceOrSelector)) {
+        var arraySelector = sourceOrSelector.map(function (el) {
+          return rec(el, {
+            path: recOpts.path,
+            schema: recOpts.schema
+          });
+        });
+        return arraySelector;
+      } else if (_typeof(sourceOrSelector) === "object") {
+        if (!sourceOrSelector) {
+          return null;
+        }
+        var richtextSelector = Object.fromEntries(Object.entries(sourceOrSelector).map(function (_ref2) {
+          var _ref3 = _slicedToArray(_ref2, 2),
+            key = _ref3[0],
+            value = _ref3[1];
+          return [key, key === "tag" || key === "styles" ? value : rec(value, {
+            path: recOpts.path,
+            schema: recOpts.schema
+          })];
+        }));
+        return richtextSelector;
+      }
+      return sourceOrSelector;
+    }
+    if (_typeof(sourceOrSelector) === "object") {
+      if (!sourceOrSelector) {
+        return null;
+      }
+      var selectorPath = Internal.getValPath(sourceOrSelector);
+      if (selectorPath) {
+        var newSchema = Internal.getSchema(sourceOrSelector);
+        return rec(opts.getModule && opts.getModule(selectorPath) !== undefined ? opts.getModule(selectorPath) : Internal.getSource(sourceOrSelector), opts.disabled ? undefined : {
+          path: selectorPath,
+          schema: newSchema === null || newSchema === void 0 ? void 0 : newSchema["executeSerialize"]()
+        });
+      }
+      if (VAL_EXTENSION in sourceOrSelector) {
+        if (sourceOrSelector[VAL_EXTENSION] === "file" && typeof sourceOrSelector[FILE_REF_PROP] === "string") {
+          var fileSelector = Internal.convertFileSource(sourceOrSelector);
+          var url = fileSelector.url;
+          return _objectSpread2(_objectSpread2({}, fileSelector), {}, {
+            url: rec(url, recOpts)
+          });
+        } else if (sourceOrSelector[VAL_EXTENSION] === "remote") {
+          var remoteSelector = Internal.convertFileSource(sourceOrSelector);
+          var _url = remoteSelector.url;
+          return _objectSpread2(_objectSpread2({}, remoteSelector), {}, {
+            url: rec(_url, recOpts)
+          });
+        }
+        console.error("Encountered unexpected extension: ".concat(sourceOrSelector[VAL_EXTENSION]));
+        return sourceOrSelector;
+      }
+      if (Array.isArray(sourceOrSelector)) {
+        return sourceOrSelector.map(function (el, i) {
+          return rec(el, recOpts && {
+            path: Internal.createValPathOfItem(recOpts.path, i),
+            schema: recOpts.schema.item
+          });
+        });
+      }
+      if (!Array.isArray(sourceOrSelector)) {
+        var res = {};
+        var entries = Object.entries(sourceOrSelector);
+        for (var _i = 0, _entries = entries; _i < _entries.length; _i++) {
+          var _entries$_i = _slicedToArray(_entries[_i], 2),
+            _key2 = _entries$_i[0],
+            value = _entries$_i[1];
+          res[_key2] = rec(value, (recOpts === null || recOpts === void 0 ? void 0 : recOpts.schema) && {
+            path: Internal.createValPathOfItem(recOpts.path, _key2),
+            schema: isRecordSchema(recOpts.schema) ? recOpts.schema.item : isObjectSchema(recOpts.schema) ? recOpts.schema.items[_key2] : unknownSchema(recOpts.schema)
+          });
+        }
+        return res;
+      }
+      console.error("Could not transform source selector: ".concat(_typeof(sourceOrSelector), " (array: ").concat(Array.isArray(sourceOrSelector), ")"), sourceOrSelector);
+      return sourceOrSelector;
+    }
+    if (typeof sourceOrSelector === "string") {
+      var _recOpts$schema, _recOpts$schema2;
+      if (!recOpts) {
+        return sourceOrSelector;
+      }
+      if ((_recOpts$schema = recOpts.schema) !== null && _recOpts$schema !== void 0 && _recOpts$schema.raw || ((_recOpts$schema2 = recOpts.schema) === null || _recOpts$schema2 === void 0 ? void 0 : _recOpts$schema2.type) === "literal") {
+        return sourceOrSelector;
+      }
+      return vercelStegaCombine(sourceOrSelector, {
+        origin: "val.build",
+        data: {
+          valPath: recOpts.path
+        }
+      }, false // auto detection on urls and dates is disabled, isDate could be used but it is also disabled (users should use a date schema instead): isDate(sourceOrSelector) // skip = true if isDate
+      );
+    }
+    if (typeof sourceOrSelector === "number" || typeof sourceOrSelector === "boolean") {
+      return sourceOrSelector;
+    }
+    console.error("Unexpected type of source selector: ".concat(_typeof(sourceOrSelector)));
+    return sourceOrSelector;
+  }
+  return rec(input);
+}
+function isRecordSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "record";
+}
+function isLiteralSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "literal";
+}
+function isDateSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "date";
+}
+function unknownSchema(schema) {
+  console.debug("Found unknown schema", schema);
+  return schema;
+}
+function isUnionSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "union";
+}
+function isKeyOfSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "keyOf";
+}
+function isRichTextSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "richtext";
+}
+function isObjectSchema(schema) {
+  return (schema === null || schema === void 0 ? void 0 : schema.type) === "object";
+}
+function stegaClean(source) {
+  return vercelStegaSplit(source).cleaned;
+}
+function getModuleIds(input) {
+  var modules = new Set();
+  function rec(sourceOrSelector) {
+    if (_typeof(sourceOrSelector) === "object") {
+      if (!sourceOrSelector) {
+        return;
+      }
+      var selectorPath = Internal.getValPath(sourceOrSelector);
+      if (selectorPath) {
+        modules.add(selectorPath);
+        return;
+      }
+      if (VAL_EXTENSION in sourceOrSelector) {
+        if (sourceOrSelector[VAL_EXTENSION] === "richtext") {
+          return;
+        }
+        if (sourceOrSelector[VAL_EXTENSION] === "file" && typeof sourceOrSelector[FILE_REF_PROP] === "string") {
+          return;
+        }
+        console.error("Encountered unexpected extension: ".concat(sourceOrSelector[VAL_EXTENSION]));
+        return sourceOrSelector;
+      }
+      if (Array.isArray(sourceOrSelector)) {
+        sourceOrSelector.forEach(rec);
+        return;
+      }
+      if (!Array.isArray(sourceOrSelector)) {
+        for (var _i2 = 0, _Object$entries = Object.entries(sourceOrSelector); _i2 < _Object$entries.length; _i2++) {
+          var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+            value = _Object$entries$_i[1];
+          rec(value);
+        }
+        return;
+      }
+      console.error("Could not transform source selector: ".concat(_typeof(sourceOrSelector), " (array: ").concat(Array.isArray(sourceOrSelector), ")"), sourceOrSelector);
+      return;
+    }
+    if (typeof sourceOrSelector === "string") {
+      return;
+    }
+    if (typeof sourceOrSelector === "number" || typeof sourceOrSelector === "boolean") {
+      return;
+    }
+    console.error("Unexpected type of source selector: ".concat(_typeof(sourceOrSelector)));
+    return;
+  }
+  rec(input);
+  return Array.from(modules);
+}
+
+function attrs(target) {
+  var allPaths = new Set();
+  function addPath(target) {
+    if (typeof target === "string") {
+      var paths = stegaDecodeStrings(target);
+      if (paths) {
+        var _iterator = _createForOfIteratorHelper(paths),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var path = _step.value;
+            allPaths.add(path);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+    }
+    if (_typeof(target) === "object" && target !== null) {
+      var _path = Internal.getValPath(target);
+      if (_path) {
+        allPaths.add(_path);
+      }
+      Object.values(target).forEach(addPath);
+    }
+  }
+  addPath(target);
+  if (allPaths.size === 0) {
+    return {};
+  }
+  return {
+    "data-val-path": Array.from(allPaths).join(",")
+  };
+}
+
+function raw(val) {
+  if (typeof val === "string") {
+    return stegaClean(val);
+  }
+  if (Array.isArray(val)) {
+    return val.map(function (item) {
+      return raw(item);
+    });
+  }
+  if (_typeof(val) === "object" && val !== null) {
+    var result = {};
+    for (var _key in val) {
+      if (Object.prototype.hasOwnProperty.call(val, _key)) {
+        result[_key] = raw(val[_key]);
+      }
+    }
+    return result;
+  }
+  return val;
+}
+
+export { _createForOfIteratorHelper as _, stegaEncode as a, stegaClean as b, attrs as c, _objectSpread2 as d, _toConsumableArray as e, getModuleIds as g, raw as r, stegaDecodeStrings as s };