@valbuild/core 0.17.0 → 0.19.0

package/dist/valbuild-core.cjs.prod.js

@@ -3,10 +3,31 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var index = require('./index-8706c87e.cjs.prod.js');
-var ops = require('./ops-0d09f8ee.cjs.prod.js');
+var ops = require('./ops-ae089ab2.cjs.prod.js');
+var marked = require('marked');
 var expr_dist_valbuildCoreExpr = require('./index-601a7d73.cjs.prod.js');
 var result = require('./result-26f67b40.cjs.prod.js');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var marked__namespace = /*#__PURE__*/_interopNamespace(marked);
+
 var NumberSchema = /*#__PURE__*/function (_Schema) {
   index._inherits(NumberSchema, _Schema);
   var _super = index._createSuper(NumberSchema);
@@ -68,10 +89,12 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
   function StringSchema(options) {
     var _this;
     var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var isRaw = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     index._classCallCheck(this, StringSchema);
     _this = _super.call(this);
     _this.options = options;
     _this.opt = opt;
+    _this.isRaw = isRaw;
     return _this;
   }
   index._createClass(StringSchema, [{
@@ -99,7 +122,12 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
   }, {
     key: "optional",
     value: function optional() {
-      return new StringSchema(this.options, true);
+      return new StringSchema(this.options, true, this.isRaw);
+    }
+  }, {
+    key: "raw",
+    value: function raw() {
+      return new StringSchema(this.options, this.opt, true);
     }
   }, {
     key: "serialize",
@@ -107,7 +135,8 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
       return {
         type: "string",
         options: this.options,
-        opt: this.opt
+        opt: this.opt,
+        raw: this.isRaw
       };
     }
   }]);
@@ -231,6 +260,115 @@ var literal = function literal(value) {
   return new LiteralSchema(value);
 };
 
+var KeyOfSchema = /*#__PURE__*/function (_Schema) {
+  index._inherits(KeyOfSchema, _Schema);
+  var _super = index._createSuper(KeyOfSchema);
+  function KeyOfSchema(selector) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    index._classCallCheck(this, KeyOfSchema);
+    _this = _super.call(this);
+    _this.selector = selector;
+    _this.opt = opt;
+    return _this;
+  }
+  index._createClass(KeyOfSchema, [{
+    key: "validate",
+    value: function validate(path, src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      var schema = this.selector[index.GetSchema];
+      if (!schema) {
+        return index._defineProperty({}, path, [{
+          message: "Schema not found for module. keyOf must be used with a Val Module"
+        }]);
+      }
+      var serializedSchema = schema.serialize();
+      if (!(serializedSchema.type === "array" || serializedSchema.type === "object" || serializedSchema.type === "record")) {
+        return index._defineProperty({}, path, [{
+          message: "Schema in keyOf must be an 'array', 'object' or 'record'. Found '".concat(serializedSchema.type, "'")
+        }]);
+      }
+      if (serializedSchema.opt && (src === null || src === undefined)) {
+        return false;
+      }
+      if (serializedSchema.type === "array" && typeof src !== "number") {
+        return index._defineProperty({}, path, [{
+          message: "Type of value in keyof (array) must be 'number'"
+        }]);
+      }
+      if (serializedSchema.type === "record" && typeof src !== "string") {
+        return index._defineProperty({}, path, [{
+          message: "Type of value in keyof (record) must be 'string'"
+        }]);
+      }
+      if (serializedSchema.type === "object") {
+        var keys = Object.keys(serializedSchema.items);
+        if (!keys.includes(src)) {
+          return index._defineProperty({}, path, [{
+            message: "Value of keyOf (object) must be: ".concat(keys.join(", "), ". Found: ").concat(src)
+          }]);
+        }
+      }
+      return false;
+    }
+  }, {
+    key: "assert",
+    value: function assert(src) {
+      if (this.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      var schema = this.selector[index.GetSchema];
+      if (!schema) {
+        return false;
+      }
+      var serializedSchema = schema.serialize();
+      if (!(serializedSchema.type === "array" || serializedSchema.type === "object" || serializedSchema.type === "record")) {
+        return false;
+      }
+      if (serializedSchema.opt && (src === null || src === undefined)) {
+        return true;
+      }
+      if (serializedSchema.type === "array" && typeof src !== "number") {
+        return false;
+      }
+      if (serializedSchema.type === "record" && typeof src !== "string") {
+        return false;
+      }
+      if (serializedSchema.type === "object") {
+        var keys = Object.keys(serializedSchema.items);
+        if (!keys.includes(src)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }, {
+    key: "optional",
+    value: function optional() {
+      return new KeyOfSchema(this.selector, true);
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      var path = index.getValPath(this.selector);
+      if (!path) {
+        throw new Error("Cannot serialize oneOf schema with empty selector. keyOf must be used with a Val Module.");
+      }
+      return {
+        type: "keyOf",
+        selector: path,
+        opt: this.opt
+      };
+    }
+  }]);
+  return KeyOfSchema;
+}(index.Schema);
+var keyOf = function keyOf(valModule) {
+  return new KeyOfSchema(valModule);
+};
+
 // import type { F } from "ts-toolbelt";
 // import { i18n, I18n } from "./schema/future/i18n";
 // import { oneOf } from "./schema/future/oneOf";
@@ -249,23 +387,145 @@ function initSchema() {
     // oneOf,
     richtext: ops.richtext,
     image: index.image,
-    literal: literal
+    literal: literal,
+    keyOf: keyOf,
+    record: ops.record
     // i18n: i18n(locales),
   };
 }
 
-function richtext(data) {
-  if (typeof data === "string") {
-    var _ref;
-    return _ref = {}, index._defineProperty(_ref, index.VAL_EXTENSION, "richtext"), index._defineProperty(_ref, "type", "root"), index._defineProperty(_ref, "children", [{
-      type: "paragraph",
-      children: [{
-        type: "text",
-        text: data
-      }]
-    }]), _ref;
+// export type FontFamily<O extends RichTextOptions> =
+//   O["fontFamily"] extends Record<string, unknown>
+//     ? `font-${keyof O["fontFamily"] & string}`
+//     : never;
+// export type FontSize<O extends RichTextOptions> = O["fontSize"] extends Record<
+//   string,
+//   unknown
+// >
+//   ? `text-${keyof O["fontSize"] & string}`
+//   : never;
+// | FontFamily<O>
+// | FontSize<O>;
+// export type AnchorNode<O extends RichTextOptions> = never; // TODO:
+// O["link"] extends true
+//   ? {
+//       tag: "a";
+//       href: string;
+//       children: [string];
+//     }
+//   : never;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// export type BlockQuoteNode<O extends RichTextOptions> =
+//   O["blockQuote"] extends true
+//     ? { tag: "blockquote"; children: [string] }
+//     : never;
+// TODO: rename to RichTextSelector?
+function parseTokens(tokens) {
+  return tokens.flatMap(function (token) {
+    if (token.type === "heading") {
+      return [{
+        tag: "h".concat(token.depth),
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "paragraph") {
+      return [{
+        tag: "p",
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "strong") {
+      return [{
+        tag: "span",
+        classes: ["bold"],
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "em") {
+      return [{
+        tag: "span",
+        classes: ["italic"],
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "del") {
+      return [{
+        tag: "span",
+        classes: ["line-through"],
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "text") {
+      return [token.text];
+    }
+    if (token.type === "list") {
+      return [{
+        tag: token.ordered ? "ol" : "ul",
+        children: parseTokens(token.items)
+      }];
+    }
+    if (token.type === "list_item") {
+      return [{
+        tag: "li",
+        children: parseTokens(token.tokens ? token.tokens : [])
+      }];
+    }
+    if (token.type === "space") {
+      return [];
+    }
+    if (token.type === "code") {
+      return [{
+        tag: "span",
+        classes: [],
+        children: [token.text]
+      }];
+    }
+    console.error("Could not parse markdown: unsupported token type: ".concat(token.type, ". Found: ").concat(token.raw));
+    return [token.raw];
+  });
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function nodeToTag(node) {
+  if (node[index.VAL_EXTENSION] === "file") {
+    return node;
   }
-  return index._objectSpread2(index._objectSpread2({}, data), {}, index._defineProperty({}, index.VAL_EXTENSION, "richtext"));
+  throw Error("Unexpected node: ".concat(JSON.stringify(node)));
+}
+function imgSrcToImgTag(imageSrc) {
+  var _imageSrc$metadata, _imageSrc$metadata2;
+  var converted = index.convertFileSource(imageSrc);
+  return {
+    tag: "img",
+    src: converted.url,
+    width: (_imageSrc$metadata = imageSrc.metadata) === null || _imageSrc$metadata === void 0 ? void 0 : _imageSrc$metadata.width,
+    height: (_imageSrc$metadata2 = imageSrc.metadata) === null || _imageSrc$metadata2 === void 0 ? void 0 : _imageSrc$metadata2.height
+  };
+}
+function convertRichTextSource(src) {
+  var _ref;
+  return _ref = {}, index._defineProperty(_ref, index.VAL_EXTENSION, "richtext"), index._defineProperty(_ref, "children", src.children.map(function (source) {
+    if (index.VAL_EXTENSION in source && source[index.VAL_EXTENSION] === "file") {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return imgSrcToImgTag(source);
+    }
+    return source;
+  })), _ref;
+}
+function richtext(templateStrings) {
+  var _ref2;
+  for (var _len = arguments.length, expr = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    expr[_key - 1] = arguments[_key];
+  }
+  return _ref2 = {}, index._defineProperty(_ref2, index.VAL_EXTENSION, "richtext"), index._defineProperty(_ref2, "children", templateStrings.flatMap(function (templateString, i) {
+    var lex = marked__namespace.lexer(templateString, {
+      gfm: true
+    });
+    if (expr[i]) {
+      return parseTokens(lex).concat(nodeToTag(expr[i]));
+    }
+    return parseTokens(lex);
+  })), _ref2;
 }
 
 // import { i18n, I18n } from "./source/future/i18n";
@@ -403,6 +663,14 @@ function derefPatch(patch, document, ops$1) {
         } else {
           dereferencedPatch.push(op);
         }
+      } else if (op.op === "file") {
+        if (op.path[0] !== "public") {
+          return result.err(new ops.PatchError("Path must start with public"));
+        }
+        if (typeof op.value !== "string") {
+          return result.err(new ops.PatchError("File operation must have a value that is typeof string. Found: ".concat(index._typeof(op.value))));
+        }
+        fileUpdates["/".concat(op.path.join("/"))] = op.value;
       } else {
         var _maybeDerefRes = derefPath(op.path);
         if (result.isErr(_maybeDerefRes)) {
@@ -896,6 +1164,32 @@ function _asyncToGenerator(fn) {
   };
 }
 
+var getSHA256Hash = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(bits) {
+    var hashBuffer, hashArray, hash;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return crypto.subtle.digest("SHA-256", bits);
+        case 2:
+          hashBuffer = _context.sent;
+          hashArray = Array.from(new Uint8Array(hashBuffer));
+          hash = hashArray.map(function (item) {
+            return item.toString(16).padStart(2, "0");
+          }).join("");
+          return _context.abrupt("return", hash);
+        case 6:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getSHA256Hash(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
 // TODO: move this to internal, only reason this is here is that react, ui and server all depend on it
 var ValApi = /*#__PURE__*/function () {
   function ValApi(host) {
@@ -1005,6 +1299,7 @@ function _parse() {
 
 var Internal = {
   convertFileSource: index.convertFileSource,
+  convertRichTextSource: convertRichTextSource,
   getSchema: index.getSchema,
   getValPath: index.getValPath,
   getVal: getVal,
@@ -1013,6 +1308,7 @@ var Internal = {
   splitModuleIdAndModulePath: ops.splitModuleIdAndModulePath,
   isVal: index.isVal,
   createValPathOfItem: ops.createValPathOfItem,
+  getSHA256Hash: getSHA256Hash,
   createPatchJSONPath: function createPatchJSONPath(modulePath) {
     return "/".concat(modulePath.split(".").map(function (segment) {
       return JSON.parse(segment);