@valbuild/react 0.13.4 → 0.14.0

package/stega/dist/valbuild-react-stega.cjs.prod.js

@@ -0,0 +1,138 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var slicedToArray = require('../../dist/slicedToArray-0eb0bcdb.cjs.prod.js');
+var ReactJSXRuntime = require('react/jsx-runtime');
+var jsxRuntimeDev = require('react/jsx-dev-runtime');
+var React = require('react');
+var stega = require('@vercel/stega');
+var objectSpread2 = require('../../dist/objectSpread2-7b752a35.cjs.prod.js');
+var core = require('@valbuild/core');
+var react = require('@valbuild/react');
+require('../../dist/unsupportedIterableToArray-afbea1dd.cjs.prod.js');
+require('../../dist/defineProperty-36ed93cd.cjs.prod.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var ReactJSXRuntime__default = /*#__PURE__*/_interopDefault(ReactJSXRuntime);
+var jsxRuntimeDev__default = /*#__PURE__*/_interopDefault(jsxRuntimeDev);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+var isIntrinsicElement = function isIntrinsicElement(type) {
+  // TODO: think this is not correct, but good enough for now?
+  return typeof type === "string";
+};
+var addValPathIfFound = function addValPathIfFound(type, props) {
+  var valSources = [];
+  if (isIntrinsicElement(type) && props && slicedToArray._typeof(props) === "object") {
+    for (var _i = 0, _Object$entries = Object.entries(props); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      if (typeof value === "string" && value.match(stega.VERCEL_STEGA_REGEX)) {
+        var encodedBits = stega.vercelStegaDecode(value);
+        if (!encodedBits || slicedToArray._typeof(encodedBits) !== "object") continue;
+        if ("origin" in encodedBits && "data" in encodedBits && slicedToArray._typeof(encodedBits.data) === "object" && encodedBits.data && "valPath" in encodedBits.data) {
+          var _encodedBits$data;
+          var valPath = encodedBits === null || encodedBits === void 0 ? void 0 : (_encodedBits$data = encodedBits.data) === null || _encodedBits$data === void 0 ? void 0 : _encodedBits$data.valPath;
+          if (valPath) {
+            console.log("Found encoded valPath", valPath);
+            valSources.push(valPath);
+            props[key] = stega.vercelStegaSplit(value).cleaned;
+          }
+        }
+      }
+    }
+    if (valSources.length > 0) {
+      props["data-val-path"] = valSources.join(",");
+    }
+  }
+};
+function WrapJsx(jsx) {
+  if (typeof jsx !== "function") return jsx;
+  return function (type, props) {
+    addValPathIfFound(type, props);
+    for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      rest[_key - 2] = arguments[_key];
+    }
+    return jsx.call.apply(jsx, [jsx, type, props].concat(rest));
+  };
+}
+function autoTagJSX() {
+  var JsxPro = ReactJSXRuntime__default["default"];
+  var JsxDev = jsxRuntimeDev__default["default"];
+
+  /**
+   * createElement _may_ be called by jsx runtime as a fallback in certain cases,
+   * so we need to wrap it regardless.
+   *
+   * The jsx exports depend on the `NODE_ENV` var to ensure the users' bundler doesn't
+   * include both, so one of them will be set with `undefined` values.
+   */
+  React__default["default"].createElement = WrapJsx(React__default["default"].createElement);
+  JsxDev.jsx && ( /*   */JsxDev.jsx = WrapJsx(JsxDev.jsx));
+  JsxPro.jsx && ( /*   */JsxPro.jsx = WrapJsx(JsxPro.jsx));
+  JsxDev.jsxs && ( /*  */JsxDev.jsxs = WrapJsx(JsxDev.jsxs));
+  JsxPro.jsxs && ( /*  */JsxPro.jsxs = WrapJsx(JsxPro.jsxs));
+  JsxDev.jsxDEV && ( /**/JsxDev.jsxDEV = WrapJsx(JsxDev.jsxDEV));
+  JsxPro.jsxDEV && ( /**/JsxPro.jsxDEV = WrapJsx(JsxPro.jsxDEV));
+}
+
+/**
+ * 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.
+ *
+ */
+
+function stegaEncodeVal(val) {
+  if (slicedToArray._typeof(val.val) === "object") {
+    if (Array.isArray(val)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return val.map(stegaEncodeVal);
+    }
+    if (slicedToArray._typeof(val.val) === "object" && val.val && "_type" in val.val && val.val["_type"] === "richtext") {
+      return objectSpread2._objectSpread2(objectSpread2._objectSpread2({}, val.val), {}, {
+        valPath: core.Internal.getValPath(val)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    }
+
+    return Object.fromEntries(Object.entries(val).map(function (_ref) {
+      var _ref2 = slicedToArray._slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return [key, stegaEncodeVal(value)];
+    }));
+  }
+  if (typeof val.val === "string") {
+    return stega.vercelStegaCombine(val.val, {
+      origin: "val.build",
+      data: {
+        valPath: core.Internal.getValPath(val)
+      }
+    }, !isDate(val.val)); // TODO: skip should false at least for URLs? Dates...?
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return val.val;
+}
+function isDate(s) {
+  return Boolean(Date.parse(s));
+}
+
+function fetchVal(selector, locale) {
+  return core.Internal.fetchVal(selector, locale).then(function (val) {
+    return stegaEncodeVal(val);
+  });
+}
+
+function useVal(selector, locale) {
+  return stegaEncodeVal(react.useVal(selector, locale));
+}
+
+exports.autoTagJSX = autoTagJSX;
+exports.fetchVal = fetchVal;
+exports.useVal = useVal;

package/stega/dist/valbuild-react-stega.esm.js

@@ -0,0 +1,126 @@
+import { a as _typeof, _ as _slicedToArray } from '../../dist/slicedToArray-d846e1d2.esm.js';
+import ReactJSXRuntime__default from 'react/jsx-runtime';
+import jsxRuntimeDev__default from 'react/jsx-dev-runtime';
+import React from 'react';
+import { VERCEL_STEGA_REGEX, vercelStegaDecode, vercelStegaSplit, vercelStegaCombine } from '@vercel/stega';
+import { _ as _objectSpread2 } from '../../dist/objectSpread2-d5a1fe1c.esm.js';
+import { Internal } from '@valbuild/core';
+import { useVal as useVal$1 } from '@valbuild/react';
+import '../../dist/unsupportedIterableToArray-51bb61c2.esm.js';
+import '../../dist/defineProperty-12b5bd29.esm.js';
+
+var isIntrinsicElement = function isIntrinsicElement(type) {
+  // TODO: think this is not correct, but good enough for now?
+  return typeof type === "string";
+};
+var addValPathIfFound = function addValPathIfFound(type, props) {
+  var valSources = [];
+  if (isIntrinsicElement(type) && props && _typeof(props) === "object") {
+    for (var _i = 0, _Object$entries = Object.entries(props); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      if (typeof value === "string" && value.match(VERCEL_STEGA_REGEX)) {
+        var encodedBits = vercelStegaDecode(value);
+        if (!encodedBits || _typeof(encodedBits) !== "object") continue;
+        if ("origin" in encodedBits && "data" in encodedBits && _typeof(encodedBits.data) === "object" && encodedBits.data && "valPath" in encodedBits.data) {
+          var _encodedBits$data;
+          var valPath = encodedBits === null || encodedBits === void 0 ? void 0 : (_encodedBits$data = encodedBits.data) === null || _encodedBits$data === void 0 ? void 0 : _encodedBits$data.valPath;
+          if (valPath) {
+            console.log("Found encoded valPath", valPath);
+            valSources.push(valPath);
+            props[key] = vercelStegaSplit(value).cleaned;
+          }
+        }
+      }
+    }
+    if (valSources.length > 0) {
+      props["data-val-path"] = valSources.join(",");
+    }
+  }
+};
+function WrapJsx(jsx) {
+  if (typeof jsx !== "function") return jsx;
+  return function (type, props) {
+    addValPathIfFound(type, props);
+    for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      rest[_key - 2] = arguments[_key];
+    }
+    return jsx.call.apply(jsx, [jsx, type, props].concat(rest));
+  };
+}
+function autoTagJSX() {
+  var JsxPro = ReactJSXRuntime__default;
+  var JsxDev = jsxRuntimeDev__default;
+
+  /**
+   * createElement _may_ be called by jsx runtime as a fallback in certain cases,
+   * so we need to wrap it regardless.
+   *
+   * The jsx exports depend on the `NODE_ENV` var to ensure the users' bundler doesn't
+   * include both, so one of them will be set with `undefined` values.
+   */
+  React.createElement = WrapJsx(React.createElement);
+  JsxDev.jsx && ( /*   */JsxDev.jsx = WrapJsx(JsxDev.jsx));
+  JsxPro.jsx && ( /*   */JsxPro.jsx = WrapJsx(JsxPro.jsx));
+  JsxDev.jsxs && ( /*  */JsxDev.jsxs = WrapJsx(JsxDev.jsxs));
+  JsxPro.jsxs && ( /*  */JsxPro.jsxs = WrapJsx(JsxPro.jsxs));
+  JsxDev.jsxDEV && ( /**/JsxDev.jsxDEV = WrapJsx(JsxDev.jsxDEV));
+  JsxPro.jsxDEV && ( /**/JsxPro.jsxDEV = WrapJsx(JsxPro.jsxDEV));
+}
+
+/**
+ * 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.
+ *
+ */
+
+function stegaEncodeVal(val) {
+  if (_typeof(val.val) === "object") {
+    if (Array.isArray(val)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return val.map(stegaEncodeVal);
+    }
+    if (_typeof(val.val) === "object" && val.val && "_type" in val.val && val.val["_type"] === "richtext") {
+      return _objectSpread2(_objectSpread2({}, val.val), {}, {
+        valPath: Internal.getValPath(val)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    }
+
+    return Object.fromEntries(Object.entries(val).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return [key, stegaEncodeVal(value)];
+    }));
+  }
+  if (typeof val.val === "string") {
+    return vercelStegaCombine(val.val, {
+      origin: "val.build",
+      data: {
+        valPath: Internal.getValPath(val)
+      }
+    }, !isDate(val.val)); // TODO: skip should false at least for URLs? Dates...?
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return val.val;
+}
+function isDate(s) {
+  return Boolean(Date.parse(s));
+}
+
+function fetchVal(selector, locale) {
+  return Internal.fetchVal(selector, locale).then(function (val) {
+    return stegaEncodeVal(val);
+  });
+}
+
+function useVal(selector, locale) {
+  return stegaEncodeVal(useVal$1(selector, locale));
+}
+
+export { autoTagJSX, fetchVal, useVal };

package/stega/dist/valbuild-react-stega.worker.esm.js

@@ -0,0 +1,147 @@
+import { a as _typeof, _ as _slicedToArray } from '../../dist/slicedToArray-9e7d1407.worker.esm.js';
+import ReactJSXRuntime__default from 'react/jsx-runtime';
+import jsxRuntimeDev__default from 'react/jsx-dev-runtime';
+import React from 'react';
+import { VERCEL_STEGA_REGEX, vercelStegaDecode, vercelStegaSplit, vercelStegaCombine } from '@vercel/stega';
+import { _ as _defineProperty } from '../../dist/defineProperty-a4bf59bc.worker.esm.js';
+import { Internal } from '@valbuild/core';
+import { useVal as useVal$1 } from '@valbuild/react';
+import '../../dist/unsupportedIterableToArray-738344ef.worker.esm.js';
+
+var isIntrinsicElement = function isIntrinsicElement(type) {
+  // TODO: think this is not correct, but good enough for now?
+  return typeof type === "string";
+};
+var addValPathIfFound = function addValPathIfFound(type, props) {
+  var valSources = [];
+  if (isIntrinsicElement(type) && props && _typeof(props) === "object") {
+    for (var _i = 0, _Object$entries = Object.entries(props); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        value = _Object$entries$_i[1];
+      if (typeof value === "string" && value.match(VERCEL_STEGA_REGEX)) {
+        var encodedBits = vercelStegaDecode(value);
+        if (!encodedBits || _typeof(encodedBits) !== "object") continue;
+        if ("origin" in encodedBits && "data" in encodedBits && _typeof(encodedBits.data) === "object" && encodedBits.data && "valPath" in encodedBits.data) {
+          var _encodedBits$data;
+          var valPath = encodedBits === null || encodedBits === void 0 ? void 0 : (_encodedBits$data = encodedBits.data) === null || _encodedBits$data === void 0 ? void 0 : _encodedBits$data.valPath;
+          if (valPath) {
+            console.log("Found encoded valPath", valPath);
+            valSources.push(valPath);
+            props[key] = vercelStegaSplit(value).cleaned;
+          }
+        }
+      }
+    }
+    if (valSources.length > 0) {
+      props["data-val-path"] = valSources.join(",");
+    }
+  }
+};
+function WrapJsx(jsx) {
+  if (typeof jsx !== "function") return jsx;
+  return function (type, props) {
+    addValPathIfFound(type, props);
+    for (var _len = arguments.length, rest = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      rest[_key - 2] = arguments[_key];
+    }
+    return jsx.call.apply(jsx, [jsx, type, props].concat(rest));
+  };
+}
+function autoTagJSX() {
+  var JsxPro = ReactJSXRuntime__default;
+  var JsxDev = jsxRuntimeDev__default;
+
+  /**
+   * createElement _may_ be called by jsx runtime as a fallback in certain cases,
+   * so we need to wrap it regardless.
+   *
+   * The jsx exports depend on the `NODE_ENV` var to ensure the users' bundler doesn't
+   * include both, so one of them will be set with `undefined` values.
+   */
+  React.createElement = WrapJsx(React.createElement);
+  JsxDev.jsx && ( /*   */JsxDev.jsx = WrapJsx(JsxDev.jsx));
+  JsxPro.jsx && ( /*   */JsxPro.jsx = WrapJsx(JsxPro.jsx));
+  JsxDev.jsxs && ( /*  */JsxDev.jsxs = WrapJsx(JsxDev.jsxs));
+  JsxPro.jsxs && ( /*  */JsxPro.jsxs = WrapJsx(JsxPro.jsxs));
+  JsxDev.jsxDEV && ( /**/JsxDev.jsxDEV = WrapJsx(JsxDev.jsxDEV));
+  JsxPro.jsxDEV && ( /**/JsxPro.jsxDEV = WrapJsx(JsxPro.jsxDEV));
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+
+/**
+ * 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.
+ *
+ */
+
+function stegaEncodeVal(val) {
+  if (_typeof(val.val) === "object") {
+    if (Array.isArray(val)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return val.map(stegaEncodeVal);
+    }
+    if (_typeof(val.val) === "object" && val.val && "_type" in val.val && val.val["_type"] === "richtext") {
+      return _objectSpread2(_objectSpread2({}, val.val), {}, {
+        valPath: Internal.getValPath(val)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      });
+    }
+
+    return Object.fromEntries(Object.entries(val).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      return [key, stegaEncodeVal(value)];
+    }));
+  }
+  if (typeof val.val === "string") {
+    return vercelStegaCombine(val.val, {
+      origin: "val.build",
+      data: {
+        valPath: Internal.getValPath(val)
+      }
+    }, !isDate(val.val)); // TODO: skip should false at least for URLs? Dates...?
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return val.val;
+}
+function isDate(s) {
+  return Boolean(Date.parse(s));
+}
+
+function fetchVal(selector, locale) {
+  return Internal.fetchVal(selector, locale).then(function (val) {
+    return stegaEncodeVal(val);
+  });
+}
+
+function useVal(selector, locale) {
+  return stegaEncodeVal(useVal$1(selector, locale));
+}
+
+export { autoTagJSX, fetchVal, useVal };

package/stega/package.json

@@ -0,0 +1,7 @@
+{
+  "main": "dist/valbuild-react-stega.cjs.js",
+  "module": "dist/valbuild-react-stega.esm.js",
+  "browser": {
+    "./dist/valbuild-react-stega.esm.js": "./dist/valbuild-react-stega.browser.esm.js"
+  }
+}

package/dist/ValProvider-d8fe7dc4.cjs.js

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === "production") {
-  module.exports = require("./ValProvider-d8fe7dc4.cjs.prod.js");
-} else {
-  module.exports = require("./ValProvider-d8fe7dc4.cjs.dev.js");
-}

package/dist/declarations/src/AuthStatus.d.ts

@@ -1,6 +0,0 @@
-export type AuthStatus = {
-    status: "not-asked" | "authenticated" | "unauthenticated" | "loading" | "local";
-} | {
-    status: "error";
-    message: string;
-};

package/dist/declarations/src/ShadowRoot.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="react" />
-export declare const ShadowRoot: ({ children }: {
-    children: React.ReactNode;
-}) => JSX.Element;

package/dist/declarations/src/ValUI.d.ts

@@ -1,8 +0,0 @@
-/// <reference types="react" />
-import { ValApi } from "./ValApi";
-import { ValStore } from "./ValStore";
-export type ValUIProps = {
-    valStore: ValStore;
-    valApi: ValApi;
-};
-export default function ValUI({ valApi, valStore }: ValUIProps): JSX.Element | null;