@player-tools/xlr-utils 0.0.2-next.0

package/dist/index.esm.js

@@ -0,0 +1,477 @@
+import * as ts from 'typescript';
+import ts__default from 'typescript';
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function extractDescription(text) {
+  if (!text) {
+    return {};
+  }
+  return { description: text };
+}
+function parentIsNonObjectPath(node) {
+  return node.parent && (ts.isArrayTypeNode(node.parent) || ts.isTupleTypeNode(node.parent) || ts.isOptionalTypeNode(node.parent) || ts.isRestTypeNode(node.parent) || ts.isUnionTypeNode(node.parent));
+}
+function recurseTypeChain(node, child) {
+  if (!node) {
+    return [];
+  }
+  if (ts.isArrayTypeNode(node) && node.parent && ts.isRestTypeNode(node.parent)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isRestTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isOptionalTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isUnionTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isParenthesizedTypeNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isTypeLiteralNode(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  if (ts.isArrayTypeNode(node)) {
+    return ["[]", ...recurseTypeChain(node.parent, node)];
+  }
+  if (ts.isTupleTypeNode(node)) {
+    const pos = node.elements.indexOf(child);
+    return [
+      ...pos === -1 ? [] : [`${pos}`],
+      ...recurseTypeChain(node.parent, node)
+    ];
+  }
+  if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isPropertySignature(node)) {
+    return [node.name.getText(), ...recurseTypeChain(node.parent, node)];
+  }
+  if (parentIsNonObjectPath(node)) {
+    return recurseTypeChain(node.parent, node);
+  }
+  return [];
+}
+function extractTitle(node) {
+  const typeNames = recurseTypeChain(node, void 0).reverse().join(".");
+  if (!typeNames.length) {
+    return {};
+  }
+  return { title: typeNames };
+}
+function stringifyDoc(docString) {
+  if (typeof docString === "undefined" || typeof docString === "string") {
+    return docString;
+  }
+  return docString.map(({ text }) => text).join(" ");
+}
+function extractTags(tags) {
+  const descriptions = [];
+  const examples = [];
+  const _default = [];
+  const see = [];
+  const extractSee = (tag) => {
+    var _a, _b, _c;
+    return `${tag.tagName ? `${(_a = tag.tagName) == null ? void 0 : _a.getText()} ` : ""}${(_c = (_b = stringifyDoc(tag.comment)) == null ? void 0 : _b.trim()) != null ? _c : ""}`;
+  };
+  tags.forEach((tag) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (!tag.comment) {
+      return;
+    }
+    if (tag.tagName.text === "example") {
+      examples.push((_b = (_a = stringifyDoc(tag.comment)) == null ? void 0 : _a.trim()) != null ? _b : "");
+    } else if (tag.tagName.text === "default") {
+      _default.push((_d = (_c = stringifyDoc(tag.comment)) == null ? void 0 : _c.trim()) != null ? _d : "");
+    } else if (tag.tagName.text === "see") {
+      see.push(extractSee(tag));
+    } else {
+      const text = (_f = (_e = stringifyDoc(tag.comment)) == null ? void 0 : _e.trim()) != null ? _f : "";
+      descriptions.push(`@${tag.tagName.text} ${text}`);
+    }
+  });
+  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
+}
+function join(t, separator = "\n") {
+  const unique = new Set(t).values();
+  return Array.from(unique).filter((s) => s !== void 0).join(separator).trim();
+}
+function mergeAnnotations(nodes) {
+  var _a;
+  const name = (_a = nodes.find((n) => n.name)) == null ? void 0 : _a.name;
+  const title = join(nodes.map((n) => n.title), ", ");
+  const description = join(nodes.map((n) => n.description));
+  const _default = join(nodes.map((n) => n.default));
+  const comment = join(nodes.map((n) => n.comment));
+  const examples = join(nodes.map((n) => Array.isArray(n.examples) ? join(n.examples) : n.examples));
+  const see = join(nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see));
+  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
+}
+function decorateNode(node) {
+  var _a;
+  const { jsDoc } = node;
+  const titleAnnotation = extractTitle(node);
+  if (jsDoc && jsDoc.length) {
+    const first = jsDoc[0];
+    return mergeAnnotations([
+      extractDescription(stringifyDoc(first.comment)),
+      titleAnnotation,
+      extractTags((_a = first.tags) != null ? _a : [])
+    ]);
+  }
+  return titleAnnotation;
+}
+
+function isOptionalProperty(node) {
+  var _a;
+  return ((_a = node.questionToken) == null ? void 0 : _a.kind) === ts__default.SyntaxKind.QuestionToken;
+}
+function isGenericInterfaceDeclaration(node) {
+  var _a;
+  const length = (_a = node.typeParameters) == null ? void 0 : _a.length;
+  return length ? length > 0 : false;
+}
+function isGenericTypeDeclaration(node) {
+  var _a;
+  const length = (_a = node.typeParameters) == null ? void 0 : _a.length;
+  return length ? length > 0 : false;
+}
+function isTypeReferenceGeneric(node, typeChecker) {
+  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && symbol.declarations) {
+    return symbol.declarations[0].kind === ts__default.SyntaxKind.TypeParameter;
+  }
+  return false;
+}
+function isTopLevelNode(node) {
+  return node.kind === ts__default.SyntaxKind.InterfaceDeclaration || node.kind === ts__default.SyntaxKind.TypeAliasDeclaration;
+}
+function isGenericNodeType(nt) {
+  var _a;
+  return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
+}
+function isGenericNamedType(nt) {
+  var _a;
+  return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
+}
+function isPrimitiveTypeNode(node) {
+  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "template" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
+}
+function isNonNullable(a) {
+  return a !== null || a !== void 0;
+}
+
+function propertyToTuple(node) {
+  var _a, _b;
+  let key = (_a = node.children) == null ? void 0 : _a[0].value;
+  if (key.includes("-")) {
+    key = `'${key}'`;
+  }
+  return {
+    key,
+    value: (_b = node.children) == null ? void 0 : _b[1]
+  };
+}
+function makePropertyMap(node) {
+  var _a;
+  const m = new Map();
+  (_a = node.children) == null ? void 0 : _a.forEach((child) => {
+    const property = propertyToTuple(child);
+    m.set(property.key, property.value);
+  });
+  return m;
+}
+function isNode(obj) {
+  return typeof obj !== "string" || typeof obj !== "number" || typeof obj !== "boolean";
+}
+function resolveConditional(conditional) {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    if (left.const && right.const) {
+      return left.const === right.const ? conditional.value.true : conditional.value.false;
+    }
+    if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
+      return conditional.value.true;
+    }
+    if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
+      return conditional.value.true;
+    }
+    if (left.type === right.type) {
+      return conditional.value.true;
+    }
+    return conditional.value.false;
+  }
+  return conditional;
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function tsStripOptionalType(node) {
+  return ts.isOptionalTypeNode(node) ? node.type : node;
+}
+function isExportedDeclaration(node) {
+  var _a;
+  return !!((_a = node.modifiers) == null ? void 0 : _a.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+}
+function isNodeExported(node) {
+  return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts.SyntaxKind.SourceFile;
+}
+function getReferencedType(node, typeChecker) {
+  var _a;
+  let symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && (symbol.flags & ts.SymbolFlags.Alias) === ts.SymbolFlags.Alias) {
+    symbol = typeChecker.getAliasedSymbol(symbol);
+  }
+  const varDecl = (_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a[0];
+  if (varDecl && (ts.isInterfaceDeclaration(varDecl) || ts.isTypeAliasDeclaration(varDecl))) {
+    return { declaration: varDecl, exported: isNodeExported(varDecl) };
+  }
+}
+function getStringLiteralsFromUnion(node) {
+  if (ts.isUnionTypeNode(node)) {
+    return new Set(node.types.map((type) => {
+      if (ts.isLiteralTypeNode(type) && ts.isStringLiteral(type.literal)) {
+        return type.literal.text;
+      }
+      return "";
+    }));
+  }
+  if (ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal)) {
+    return new Set([node.literal.text]);
+  }
+  return new Set();
+}
+function buildTemplateRegex(node, typeChecker) {
+  let regex = node.head.text;
+  node.templateSpans.forEach((span) => {
+    var _a;
+    let type = span.type.kind;
+    if (ts.isTypeReferenceNode(span.type)) {
+      let symbol = typeChecker.getSymbolAtLocation(span.type.typeName);
+      if (symbol && (symbol.flags & ts.SymbolFlags.Alias) === ts.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      type = ((_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a[0]).type.kind;
+    }
+    if (type === ts.SyntaxKind.StringKeyword) {
+      regex += ".*";
+    } else if (type === ts.SyntaxKind.NumberKeyword) {
+      regex += "[0-9]*";
+    } else if (type === ts.SyntaxKind.BooleanKeyword) {
+      regex += "true|false";
+    }
+    regex += span.literal.text;
+  });
+  return regex;
+}
+function fillInGenerics(xlrNode, generics) {
+  var _a;
+  let localGenerics;
+  if (generics) {
+    localGenerics = new Map(generics);
+  } else {
+    localGenerics = new Map();
+    if (isGenericNodeType(xlrNode)) {
+      (_a = xlrNode.genericTokens) == null ? void 0 : _a.forEach((token) => {
+        var _a2;
+        localGenerics.set(token.symbol, (_a2 = token.default) != null ? _a2 : token.constraints);
+      });
+    }
+  }
+  if (xlrNode.type === "ref") {
+    if (localGenerics.has(xlrNode.ref)) {
+      return __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, localGenerics.get(xlrNode.ref)), xlrNode.genericArguments ? {
+        genericArguments: xlrNode.genericArguments.map((ga) => fillInGenerics(ga, localGenerics))
+      } : {}), xlrNode.title ? { title: xlrNode.title } : {}), xlrNode.name ? { name: xlrNode.name } : {}), xlrNode.description ? { description: xlrNode.description } : {}), xlrNode.comment ? { comment: xlrNode.comment } : {});
+    }
+    return __spreadValues(__spreadValues({}, xlrNode), xlrNode.genericArguments ? {
+      genericArguments: xlrNode.genericArguments.map((ga) => fillInGenerics(ga, localGenerics))
+    } : {});
+  }
+  if (xlrNode.type === "object") {
+    const newProperties = {};
+    Object.getOwnPropertyNames(xlrNode.properties).forEach((propName) => {
+      const prop = xlrNode.properties[propName];
+      newProperties[propName] = {
+        required: prop.required,
+        node: fillInGenerics(prop.node, localGenerics)
+      };
+    });
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      properties: newProperties
+    });
+  }
+  if (xlrNode.type === "array") {
+    xlrNode.elementType = fillInGenerics(xlrNode.elementType, localGenerics);
+  } else if (xlrNode.type === "or" || xlrNode.type === "and") {
+    let pointer;
+    if (xlrNode.type === "or") {
+      pointer = xlrNode.or;
+    } else {
+      pointer = xlrNode.and;
+    }
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      [xlrNode.type]: pointer.map((prop) => {
+        return fillInGenerics(prop, localGenerics);
+      })
+    });
+  } else if (xlrNode.type === "record") {
+    return __spreadProps(__spreadValues({}, xlrNode), {
+      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
+      valueType: fillInGenerics(xlrNode.valueType, localGenerics)
+    });
+  } else if (xlrNode.type === "conditional") {
+    const filledInConditional = __spreadProps(__spreadValues({}, xlrNode), {
+      check: {
+        left: fillInGenerics(xlrNode.check.left, localGenerics),
+        right: fillInGenerics(xlrNode.check.right, localGenerics)
+      },
+      value: {
+        true: fillInGenerics(xlrNode.value.true, localGenerics),
+        false: fillInGenerics(xlrNode.value.false, localGenerics)
+      }
+    });
+    if (filledInConditional.check.left.type !== "ref" && filledInConditional.check.right.type !== "ref") {
+      return __spreadValues({
+        name: xlrNode.name,
+        title: xlrNode.title
+      }, resolveConditional(filledInConditional));
+    }
+    return filledInConditional;
+  }
+  return xlrNode;
+}
+function applyPickOrOmitToNodeType(baseObject, operation, properties) {
+  if (baseObject.type === "object") {
+    const newObject = __spreadValues({}, baseObject);
+    Object.keys(baseObject.properties).forEach((key) => {
+      if (operation === "Omit" && properties.has(key) || operation === "Pick" && !properties.has(key)) {
+        delete newObject.properties[key];
+      }
+    });
+    if (Object.keys(newObject.properties).length === 0 && (operation !== "Omit" || newObject.additionalProperties === false)) {
+      return void 0;
+    }
+    return newObject;
+  }
+  let pointer;
+  if (baseObject.type === "and") {
+    pointer = baseObject.and;
+  } else if (baseObject.type === "or") {
+    pointer = baseObject.or;
+  } else {
+    throw new Error(`Error: Can not apply ${operation} to type ${baseObject.type}`);
+  }
+  const pickedTypes = pointer.map((type) => {
+    const node = applyPickOrOmitToNodeType(type, operation, properties);
+    if (node === void 0) {
+      return void 0;
+    }
+    return __spreadProps(__spreadValues({}, node), { additionalProperties: false });
+  }).filter((type) => type !== void 0);
+  if (pickedTypes.length === 0) {
+    return void 0;
+  }
+  if (pickedTypes.length === 1) {
+    return pickedTypes[0];
+  }
+  if (baseObject.type === "and") {
+    return __spreadProps(__spreadValues({}, baseObject), { and: pickedTypes });
+  }
+  return __spreadProps(__spreadValues({}, baseObject), { or: pickedTypes });
+}
+function applyPartialOrRequiredToNodeType(baseObject, modifier) {
+  if (baseObject.type === "object") {
+    const newObject = __spreadValues({}, baseObject);
+    Object.keys(baseObject.properties).forEach((key) => {
+      newObject.properties[key].required = modifier;
+    });
+    return newObject;
+  }
+  if (baseObject.type === "and") {
+    const pickedTypes = baseObject.and.map((type) => applyPartialOrRequiredToNodeType(type, modifier));
+    return __spreadProps(__spreadValues({}, baseObject), { and: pickedTypes });
+  }
+  if (baseObject.type === "or") {
+    const pickedTypes = baseObject.or.map((type) => applyPartialOrRequiredToNodeType(type, modifier));
+    return __spreadProps(__spreadValues({}, baseObject), { or: pickedTypes });
+  }
+  throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
+}
+
+function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
+  const sourceFile = ts.createSourceFile(mockFileName, sourceCode, ts.ScriptTarget.Latest, true);
+  const compilerHost = {
+    getSourceFile(filename) {
+      if (filename === mockFileName) {
+        return sourceFile;
+      }
+      return void 0;
+    },
+    writeFile(name, text, writeByteOrderMark) {
+    },
+    getDefaultLibFileName() {
+      return "lib.d.ts";
+    },
+    useCaseSensitiveFileNames() {
+      return false;
+    },
+    getCanonicalFileName(filename) {
+      return filename;
+    },
+    getCurrentDirectory() {
+      return "";
+    },
+    getNewLine() {
+      return "\n";
+    },
+    fileExists(fileName) {
+      if (fileName === mockFileName) {
+        return true;
+      }
+      return false;
+    },
+    readFile(fileName) {
+      if (fileName === mockFileName) {
+        return sourceCode;
+      }
+      return void 0;
+    }
+  };
+  const program = ts.createProgram([mockFileName], {}, compilerHost);
+  return { sf: sourceFile, tc: program.getTypeChecker() };
+}
+
+export { applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, setupTestEnv, tsStripOptionalType };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@player-tools/xlr-utils",
+  "version": "0.0.2-next.0",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "typescript": "4.4.4",
+    "jsonc-parser": "^2.3.1"
+  },
+  "dependencies": {
+    "@player-tools/xlr": "0.0.2-next.0",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/player-ui/tools"
+  },
+  "bugs": {
+    "url": "https://github.com/player-ui/tools/issues"
+  },
+  "homepage": "https://player-ui.github.io",
+  "contributors": [
+    {
+      "name": "Ketan Reddy",
+      "url": "https://github.com/KetanReddy"
+    }
+  ]
+}