@osdk/maker-experimental 0.4.0-beta.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,60 @@
 # @osdk/maker-experimental
 
+## 0.4.0
+
+### Patch Changes
+
+- 425cb92: Simulated release
+- af4f3bf: Remove the following features for RC:
+  - Property formatting
+  - Branching
+  - Constant RDPs
+
+- Updated dependencies [322c5bc]
+- Updated dependencies [f7ae38a]
+- Updated dependencies [486ef7e]
+- Updated dependencies [ea077c6]
+- Updated dependencies [3d7dc0a]
+- Updated dependencies [2556c64]
+- Updated dependencies [5a9cd8f]
+- Updated dependencies [b307201]
+- Updated dependencies [e7bf02a]
+- Updated dependencies [a1ffb20]
+- Updated dependencies [b959085]
+- Updated dependencies [af4f3bf]
+- Updated dependencies [e62c692]
+  - @osdk/api@2.6.0
+
+## 0.4.0-rc.2
+
+### Patch Changes
+
+- af4f3bf: Remove the following features for RC:
+  - Property formatting
+  - Branching
+  - Constant RDPs
+
+- Updated dependencies [af4f3bf]
+  - @osdk/api@2.6.0-rc.14
+
+## 0.3.0
+
+### Patch Changes
+
+- 425cb92: Simulated release
+- a6f49e9: Fix Maker Rid Generation
+- Updated dependencies [322c5bc]
+- Updated dependencies [7160276]
+- Updated dependencies [7bdac45]
+- Updated dependencies [37eb75b]
+- Updated dependencies [7b97128]
+- Updated dependencies [76905f5]
+- Updated dependencies [20962bc]
+- Updated dependencies [052a96b]
+- Updated dependencies [ca1fabe]
+- Updated dependencies [e48be06]
+  - @osdk/api@2.5.0
+
 ## 0.3.0-beta.5
 
 ### Minor Changes

package/build/cjs/index.cjs

@@ -2240,6 +2240,557 @@ function convertToPluralDisplayName(s2) {
   return s2 === void 0 || s2 == null ? "" : s2.endsWith("s") ? uppercaseFirstLetter(s2) : uppercaseFirstLetter(s2) + "s";
 }
 
+// ../../node_modules/.pnpm/outdent@0.8.0/node_modules/outdent/lib-module/index.js
+function noop() {
+}
+function createWeakMap() {
+  if (typeof WeakMap !== "undefined") {
+    return /* @__PURE__ */ new WeakMap();
+  } else {
+    return fakeSetOrMap();
+  }
+}
+function fakeSetOrMap() {
+  return {
+    add: noop,
+    delete: noop,
+    get: noop,
+    set: noop,
+    has: function(k) {
+      return false;
+    }
+  };
+}
+var hop = Object.prototype.hasOwnProperty;
+var has = function(obj, prop) {
+  return hop.call(obj, prop);
+};
+function extend(target, source) {
+  for (var prop in source) {
+    if (has(source, prop)) {
+      target[prop] = source[prop];
+    }
+  }
+  return target;
+}
+var reLeadingNewline = /^[ \t]*(?:\r\n|\r|\n)/;
+var reTrailingNewline = /(?:\r\n|\r|\n)[ \t]*$/;
+var reStartsWithNewlineOrIsEmpty = /^(?:[\r\n]|$)/;
+var reDetectIndentation = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/;
+var reOnlyWhitespaceWithAtLeastOneNewline = /^[ \t]*[\r\n][ \t\r\n]*$/;
+function _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options) {
+  var indentationLevel = 0;
+  var match = strings[0].match(reDetectIndentation);
+  if (match) {
+    indentationLevel = match[1].length;
+  }
+  var reSource = "(\\r\\n|\\r|\\n).{0," + indentationLevel + "}";
+  var reMatchIndent = new RegExp(reSource, "g");
+  if (firstInterpolatedValueSetsIndentationLevel) {
+    strings = strings.slice(1);
+  }
+  var newline = options.newline, trimLeadingNewline = options.trimLeadingNewline, trimTrailingNewline = options.trimTrailingNewline;
+  var normalizeNewlines = typeof newline === "string";
+  var l2 = strings.length;
+  var outdentedStrings = strings.map(function(v, i2) {
+    v = v.replace(reMatchIndent, "$1");
+    if (i2 === 0 && trimLeadingNewline) {
+      v = v.replace(reLeadingNewline, "");
+    }
+    if (i2 === l2 - 1 && trimTrailingNewline) {
+      v = v.replace(reTrailingNewline, "");
+    }
+    if (normalizeNewlines) {
+      v = v.replace(/\r\n|\n|\r/g, function(_2) {
+        return newline;
+      });
+    }
+    return v;
+  });
+  return outdentedStrings;
+}
+function concatStringsAndValues(strings, values) {
+  var ret = "";
+  for (var i2 = 0, l2 = strings.length; i2 < l2; i2++) {
+    ret += strings[i2];
+    if (i2 < l2 - 1) {
+      ret += values[i2];
+    }
+  }
+  return ret;
+}
+function isTemplateStringsArray(v) {
+  return has(v, "raw") && has(v, "length");
+}
+function createInstance(options) {
+  var arrayAutoIndentCache = createWeakMap();
+  var arrayFirstInterpSetsIndentCache = createWeakMap();
+  function outdent(stringsOrOptions) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      values[_i - 1] = arguments[_i];
+    }
+    if (isTemplateStringsArray(stringsOrOptions)) {
+      var strings = stringsOrOptions;
+      var firstInterpolatedValueSetsIndentationLevel = (values[0] === outdent || values[0] === defaultOutdent) && reOnlyWhitespaceWithAtLeastOneNewline.test(strings[0]) && reStartsWithNewlineOrIsEmpty.test(strings[1]);
+      var cache = firstInterpolatedValueSetsIndentationLevel ? arrayFirstInterpSetsIndentCache : arrayAutoIndentCache;
+      var renderedArray = cache.get(strings);
+      if (!renderedArray) {
+        renderedArray = _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+        cache.set(strings, renderedArray);
+      }
+      if (values.length === 0) {
+        return renderedArray[0];
+      }
+      var rendered = concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+      return rendered;
+    } else {
+      return createInstance(extend(extend({}, options), stringsOrOptions || {}));
+    }
+  }
+  var fullOutdent = extend(outdent, {
+    string: function(str) {
+      return _outdentArray([str], false, options)[0];
+    }
+  });
+  return fullOutdent;
+}
+var defaultOutdent = createInstance({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true
+});
+if (typeof module !== "undefined") {
+  try {
+    module.exports = defaultOutdent;
+    Object.defineProperty(defaultOutdent, "__esModule", {
+      value: true
+    });
+    defaultOutdent.default = defaultOutdent;
+    defaultOutdent.outdent = defaultOutdent;
+  } catch (e) {
+  }
+}
+
+// ../../node_modules/.pnpm/mustache@4.2.0/node_modules/mustache/mustache.mjs
+var objectToString = Object.prototype.toString;
+var isArray = Array.isArray || function isArrayPolyfill(object) {
+  return objectToString.call(object) === "[object Array]";
+};
+function isFunction2(object) {
+  return typeof object === "function";
+}
+function typeStr(obj) {
+  return isArray(obj) ? "array" : typeof obj;
+}
+function escapeRegExp(string) {
+  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+function hasProperty(obj, propName) {
+  return obj != null && typeof obj === "object" && propName in obj;
+}
+function primitiveHasOwnProperty(primitive, propName) {
+  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
+}
+var regExpTest = RegExp.prototype.test;
+function testRegExp(re, string) {
+  return regExpTest.call(re, string);
+}
+var nonSpaceRe = /\S/;
+function isWhitespace(string) {
+  return !testRegExp(nonSpaceRe, string);
+}
+var entityMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+function escapeHtml(string) {
+  return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap(s2) {
+    return entityMap[s2];
+  });
+}
+var whiteRe = /\s*/;
+var spaceRe = /\s+/;
+var equalsRe = /\s*=/;
+var curlyRe = /\s*\}/;
+var tagRe = /#|\^|\/|>|\{|&|=|!/;
+function parseTemplate(template, tags) {
+  if (!template) return [];
+  var lineHasNonSpace = false;
+  var sections = [];
+  var tokens = [];
+  var spaces = [];
+  var hasTag = false;
+  var nonSpace = false;
+  var indentation = "";
+  var tagIndex = 0;
+  function stripSpace() {
+    if (hasTag && !nonSpace) {
+      while (spaces.length) delete tokens[spaces.pop()];
+    } else {
+      spaces = [];
+    }
+    hasTag = false;
+    nonSpace = false;
+  }
+  var openingTagRe, closingTagRe, closingCurlyRe;
+  function compileTags(tagsToCompile) {
+    if (typeof tagsToCompile === "string") tagsToCompile = tagsToCompile.split(spaceRe, 2);
+    if (!isArray(tagsToCompile) || tagsToCompile.length !== 2) throw new Error("Invalid tags: " + tagsToCompile);
+    openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + "\\s*");
+    closingTagRe = new RegExp("\\s*" + escapeRegExp(tagsToCompile[1]));
+    closingCurlyRe = new RegExp("\\s*" + escapeRegExp("}" + tagsToCompile[1]));
+  }
+  compileTags(tags || mustache.tags);
+  var scanner = new Scanner(template);
+  var start, type, value, chr, token, openSection;
+  while (!scanner.eos()) {
+    start = scanner.pos;
+    value = scanner.scanUntil(openingTagRe);
+    if (value) {
+      for (var i2 = 0, valueLength = value.length; i2 < valueLength; ++i2) {
+        chr = value.charAt(i2);
+        if (isWhitespace(chr)) {
+          spaces.push(tokens.length);
+          indentation += chr;
+        } else {
+          nonSpace = true;
+          lineHasNonSpace = true;
+          indentation += " ";
+        }
+        tokens.push(["text", chr, start, start + 1]);
+        start += 1;
+        if (chr === "\n") {
+          stripSpace();
+          indentation = "";
+          tagIndex = 0;
+          lineHasNonSpace = false;
+        }
+      }
+    }
+    if (!scanner.scan(openingTagRe)) break;
+    hasTag = true;
+    type = scanner.scan(tagRe) || "name";
+    scanner.scan(whiteRe);
+    if (type === "=") {
+      value = scanner.scanUntil(equalsRe);
+      scanner.scan(equalsRe);
+      scanner.scanUntil(closingTagRe);
+    } else if (type === "{") {
+      value = scanner.scanUntil(closingCurlyRe);
+      scanner.scan(curlyRe);
+      scanner.scanUntil(closingTagRe);
+      type = "&";
+    } else {
+      value = scanner.scanUntil(closingTagRe);
+    }
+    if (!scanner.scan(closingTagRe)) throw new Error("Unclosed tag at " + scanner.pos);
+    if (type == ">") {
+      token = [type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace];
+    } else {
+      token = [type, value, start, scanner.pos];
+    }
+    tagIndex++;
+    tokens.push(token);
+    if (type === "#" || type === "^") {
+      sections.push(token);
+    } else if (type === "/") {
+      openSection = sections.pop();
+      if (!openSection) throw new Error('Unopened section "' + value + '" at ' + start);
+      if (openSection[1] !== value) throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+    } else if (type === "name" || type === "{" || type === "&") {
+      nonSpace = true;
+    } else if (type === "=") {
+      compileTags(value);
+    }
+  }
+  stripSpace();
+  openSection = sections.pop();
+  if (openSection) throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
+  return nestTokens(squashTokens(tokens));
+}
+function squashTokens(tokens) {
+  var squashedTokens = [];
+  var token, lastToken;
+  for (var i2 = 0, numTokens = tokens.length; i2 < numTokens; ++i2) {
+    token = tokens[i2];
+    if (token) {
+      if (token[0] === "text" && lastToken && lastToken[0] === "text") {
+        lastToken[1] += token[1];
+        lastToken[3] = token[3];
+      } else {
+        squashedTokens.push(token);
+        lastToken = token;
+      }
+    }
+  }
+  return squashedTokens;
+}
+function nestTokens(tokens) {
+  var nestedTokens = [];
+  var collector = nestedTokens;
+  var sections = [];
+  var token, section;
+  for (var i2 = 0, numTokens = tokens.length; i2 < numTokens; ++i2) {
+    token = tokens[i2];
+    switch (token[0]) {
+      case "#":
+      case "^":
+        collector.push(token);
+        sections.push(token);
+        collector = token[4] = [];
+        break;
+      case "/":
+        section = sections.pop();
+        section[5] = token[2];
+        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+        break;
+      default:
+        collector.push(token);
+    }
+  }
+  return nestedTokens;
+}
+function Scanner(string) {
+  this.string = string;
+  this.tail = string;
+  this.pos = 0;
+}
+Scanner.prototype.eos = function eos() {
+  return this.tail === "";
+};
+Scanner.prototype.scan = function scan(re) {
+  var match = this.tail.match(re);
+  if (!match || match.index !== 0) return "";
+  var string = match[0];
+  this.tail = this.tail.substring(string.length);
+  this.pos += string.length;
+  return string;
+};
+Scanner.prototype.scanUntil = function scanUntil(re) {
+  var index = this.tail.search(re), match;
+  switch (index) {
+    case -1:
+      match = this.tail;
+      this.tail = "";
+      break;
+    case 0:
+      match = "";
+      break;
+    default:
+      match = this.tail.substring(0, index);
+      this.tail = this.tail.substring(index);
+  }
+  this.pos += match.length;
+  return match;
+};
+function Context(view, parentContext) {
+  this.view = view;
+  this.cache = {
+    ".": this.view
+  };
+  this.parent = parentContext;
+}
+Context.prototype.push = function push(view) {
+  return new Context(view, this);
+};
+Context.prototype.lookup = function lookup(name) {
+  var cache = this.cache;
+  var value;
+  if (cache.hasOwnProperty(name)) {
+    value = cache[name];
+  } else {
+    var context = this, intermediateValue, names, index, lookupHit = false;
+    while (context) {
+      if (name.indexOf(".") > 0) {
+        intermediateValue = context.view;
+        names = name.split(".");
+        index = 0;
+        while (intermediateValue != null && index < names.length) {
+          if (index === names.length - 1) lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
+          intermediateValue = intermediateValue[names[index++]];
+        }
+      } else {
+        intermediateValue = context.view[name];
+        lookupHit = hasProperty(context.view, name);
+      }
+      if (lookupHit) {
+        value = intermediateValue;
+        break;
+      }
+      context = context.parent;
+    }
+    cache[name] = value;
+  }
+  if (isFunction2(value)) value = value.call(this.view);
+  return value;
+};
+function Writer() {
+  this.templateCache = {
+    _cache: {},
+    set: function set(key, value) {
+      this._cache[key] = value;
+    },
+    get: function get(key) {
+      return this._cache[key];
+    },
+    clear: function clear() {
+      this._cache = {};
+    }
+  };
+}
+Writer.prototype.clearCache = function clearCache() {
+  if (typeof this.templateCache !== "undefined") {
+    this.templateCache.clear();
+  }
+};
+Writer.prototype.parse = function parse(template, tags) {
+  var cache = this.templateCache;
+  var cacheKey = template + ":" + (tags || mustache.tags).join(":");
+  var isCacheEnabled = typeof cache !== "undefined";
+  var tokens = isCacheEnabled ? cache.get(cacheKey) : void 0;
+  if (tokens == void 0) {
+    tokens = parseTemplate(template, tags);
+    isCacheEnabled && cache.set(cacheKey, tokens);
+  }
+  return tokens;
+};
+Writer.prototype.render = function render(template, view, partials, config) {
+  var tags = this.getConfigTags(config);
+  var tokens = this.parse(template, tags);
+  var context = view instanceof Context ? view : new Context(view, void 0);
+  return this.renderTokens(tokens, context, partials, template, config);
+};
+Writer.prototype.renderTokens = function renderTokens(tokens, context, partials, originalTemplate, config) {
+  var buffer = "";
+  var token, symbol, value;
+  for (var i2 = 0, numTokens = tokens.length; i2 < numTokens; ++i2) {
+    value = void 0;
+    token = tokens[i2];
+    symbol = token[0];
+    if (symbol === "#") value = this.renderSection(token, context, partials, originalTemplate, config);
+    else if (symbol === "^") value = this.renderInverted(token, context, partials, originalTemplate, config);
+    else if (symbol === ">") value = this.renderPartial(token, context, partials, config);
+    else if (symbol === "&") value = this.unescapedValue(token, context);
+    else if (symbol === "name") value = this.escapedValue(token, context, config);
+    else if (symbol === "text") value = this.rawValue(token);
+    if (value !== void 0) buffer += value;
+  }
+  return buffer;
+};
+Writer.prototype.renderSection = function renderSection(token, context, partials, originalTemplate, config) {
+  var self = this;
+  var buffer = "";
+  var value = context.lookup(token[1]);
+  function subRender(template) {
+    return self.render(template, context, partials, config);
+  }
+  if (!value) return;
+  if (isArray(value)) {
+    for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
+      buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);
+    }
+  } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+    buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);
+  } else if (isFunction2(value)) {
+    if (typeof originalTemplate !== "string") throw new Error("Cannot use higher-order sections without the original template");
+    value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
+    if (value != null) buffer += value;
+  } else {
+    buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);
+  }
+  return buffer;
+};
+Writer.prototype.renderInverted = function renderInverted(token, context, partials, originalTemplate, config) {
+  var value = context.lookup(token[1]);
+  if (!value || isArray(value) && value.length === 0) return this.renderTokens(token[4], context, partials, originalTemplate, config);
+};
+Writer.prototype.indentPartial = function indentPartial(partial, indentation, lineHasNonSpace) {
+  var filteredIndentation = indentation.replace(/[^ \t]/g, "");
+  var partialByNl = partial.split("\n");
+  for (var i2 = 0; i2 < partialByNl.length; i2++) {
+    if (partialByNl[i2].length && (i2 > 0 || !lineHasNonSpace)) {
+      partialByNl[i2] = filteredIndentation + partialByNl[i2];
+    }
+  }
+  return partialByNl.join("\n");
+};
+Writer.prototype.renderPartial = function renderPartial(token, context, partials, config) {
+  if (!partials) return;
+  var tags = this.getConfigTags(config);
+  var value = isFunction2(partials) ? partials(token[1]) : partials[token[1]];
+  if (value != null) {
+    var lineHasNonSpace = token[6];
+    var tagIndex = token[5];
+    var indentation = token[4];
+    var indentedValue = value;
+    if (tagIndex == 0 && indentation) {
+      indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
+    }
+    var tokens = this.parse(indentedValue, tags);
+    return this.renderTokens(tokens, context, partials, indentedValue, config);
+  }
+};
+Writer.prototype.unescapedValue = function unescapedValue(token, context) {
+  var value = context.lookup(token[1]);
+  if (value != null) return value;
+};
+Writer.prototype.escapedValue = function escapedValue(token, context, config) {
+  var escape = this.getConfigEscape(config) || mustache.escape;
+  var value = context.lookup(token[1]);
+  if (value != null) return typeof value === "number" && escape === mustache.escape ? String(value) : escape(value);
+};
+Writer.prototype.rawValue = function rawValue(token) {
+  return token[1];
+};
+Writer.prototype.getConfigTags = function getConfigTags(config) {
+  if (isArray(config)) {
+    return config;
+  } else if (config && typeof config === "object") {
+    return config.tags;
+  } else {
+    return void 0;
+  }
+};
+Writer.prototype.getConfigEscape = function getConfigEscape(config) {
+  if (config && typeof config === "object" && !isArray(config)) {
+    return config.escape;
+  } else {
+    return void 0;
+  }
+};
+var mustache = {
+  tags: ["{{", "}}"],
+  clearCache: void 0,
+  escape: void 0,
+  parse: void 0,
+  render: void 0,
+  Scanner: void 0,
+  Context: void 0,
+  Writer: void 0};
+var defaultWriter = new Writer();
+mustache.clearCache = function clearCache2() {
+  return defaultWriter.clearCache();
+};
+mustache.parse = function parse2(template, tags) {
+  return defaultWriter.parse(template, tags);
+};
+mustache.render = function render2(template, view, partials, config) {
+  if (typeof template !== "string") {
+    throw new TypeError('Invalid template! Template should be a "string" but "' + typeStr(template) + '" was given as the first argument for mustache#render(template, view, partials)');
+  }
+  return defaultWriter.render(template, view, partials, config);
+};
+mustache.escape = escapeHtml;
+mustache.Scanner = Scanner;
+mustache.Context = Context;
+mustache.Writer = Writer;
+
 // ../maker/build/esm/api/defineOntology.js
 var importedTypes;
 
@@ -2296,6 +2847,12 @@ yargs-parser/build/lib/index.js:
    * Copyright (c) 2016, Contributors
    * SPDX-License-Identifier: ISC
    *)
+
+mustache/mustache.mjs:
+  (*!
+   * mustache.js - Logic-less {{mustache}} templates with JavaScript
+   * http://github.com/janl/mustache.js
+   *)
 */
 
 exports.defineImportObject = defineImportObject;