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

package/dist/index.esm.js

@@ -0,0 +1,480 @@
+import { isPrimitiveTypeNode, resolveConditional, makePropertyMap, isGenericNodeType, fillInGenerics } from '@player-tools/xlr-utils';
+import { TSWriter } from '@player-tools/xlr-converters';
+import fs from 'fs';
+import path from 'path';
+import ts 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;
+};
+class BasicXLRRegistry {
+  constructor() {
+    this.typeMap = new Map();
+    this.pluginMap = new Map();
+    this.infoMap = new Map();
+  }
+  get(id) {
+    const value = this.typeMap.get(id);
+    return value ? __spreadValues$1({}, value) : void 0;
+  }
+  add(type, plugin, capability) {
+    this.typeMap.set(type.name, type);
+    this.infoMap.set(type.name, { plugin, capability });
+    if (!this.pluginMap.has(plugin)) {
+      this.pluginMap.set(plugin, new Map());
+    }
+    const pluginsCapabilities = this.pluginMap.get(plugin);
+    if (!pluginsCapabilities.has(capability)) {
+      pluginsCapabilities.set(capability, []);
+    }
+    const providedCapabilities = pluginsCapabilities.get(capability);
+    providedCapabilities.push(type.name);
+  }
+  has(id) {
+    return this.typeMap.has(id);
+  }
+  list(filterArgs) {
+    const validTypes = [];
+    this.pluginMap.forEach((manifest, pluginName) => {
+      if (!(filterArgs == null ? void 0 : filterArgs.pluginFilter) || !pluginName.match(filterArgs.pluginFilter)) {
+        manifest.forEach((types, capabilityName) => {
+          if (!(filterArgs == null ? void 0 : filterArgs.capabilityFilter) || !capabilityName.match(filterArgs.capabilityFilter)) {
+            types.forEach((type) => {
+              if (!(filterArgs == null ? void 0 : filterArgs.typeFilter) || !type.match(filterArgs.typeFilter)) {
+                validTypes.push(type);
+              }
+            });
+          }
+        });
+      }
+    });
+    return validTypes.map((type) => this.get(type));
+  }
+  info(id) {
+    return this.infoMap.get(id);
+  }
+}
+
+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));
+class XLRValidator {
+  constructor(typeMap) {
+    this.typeMap = typeMap;
+    this.regexCache = new Map();
+  }
+  validateType(rootNode, xlrNode) {
+    var _a;
+    const validationIssues = new Array();
+    if (xlrNode.type === "object") {
+      if (rootNode.type === "object") {
+        validationIssues.push(...this.validateObject(xlrNode, rootNode));
+      } else {
+        validationIssues.push({
+          type: "type",
+          node: rootNode,
+          message: `Expected an object but got an '${rootNode.type}'`
+        });
+      }
+    } else if (xlrNode.type === "array") {
+      if (rootNode.type === "array") {
+        validationIssues.push(...this.validateArray(rootNode, xlrNode));
+      } else {
+        validationIssues.push({
+          type: "type",
+          node: rootNode,
+          message: `Expected an array but got an '${rootNode.type}'`
+        });
+      }
+    } else if (xlrNode.type === "template") {
+      this.validateTemplate(rootNode, xlrNode);
+    } else if (xlrNode.type === "or") {
+      for (const potentialType of xlrNode.or) {
+        const potentialErrors = this.validateType(rootNode, potentialType);
+        if (potentialErrors.length === 0) {
+          return validationIssues;
+        }
+      }
+      validationIssues.push({
+        type: "value",
+        node: rootNode,
+        message: `Does not match any of the expected types for type: '${xlrNode.name}'`
+      });
+    } else if (xlrNode.type === "and") {
+      const effectiveType = this.computeIntersectionType(xlrNode.and);
+      validationIssues.push(...this.validateType(rootNode, effectiveType));
+    } else if (xlrNode.type === "record") {
+      (_a = rootNode.children) == null ? void 0 : _a.forEach((child) => {
+        var _a2, _b;
+        validationIssues.push(...this.validateType((_a2 = child.children) == null ? void 0 : _a2[0], xlrNode.keyType));
+        validationIssues.push(...this.validateType((_b = child.children) == null ? void 0 : _b[1], xlrNode.valueType));
+      });
+    } else if (xlrNode.type === "ref") {
+      const refType = this.getRefType(xlrNode);
+      if (refType === void 0) {
+        validationIssues.push({
+          type: "unknown",
+          node: rootNode,
+          message: `Type '${xlrNode.ref}' is not defined in provided bundles`
+        });
+      } else {
+        validationIssues.push(...this.validateType(rootNode, refType));
+      }
+    } else if (isPrimitiveTypeNode(xlrNode)) {
+      if (!this.validateLiteralType(xlrNode, rootNode)) {
+        if ((xlrNode.type === "string" || xlrNode.type === "number" || xlrNode.type === "boolean") && xlrNode.const) {
+          validationIssues.push({
+            type: "type",
+            node: rootNode.parent,
+            message: `Expected '${xlrNode.const}' but got '${rootNode.value}'`
+          });
+        } else {
+          validationIssues.push({
+            type: "type",
+            node: rootNode.parent,
+            message: `Expected type '${xlrNode.type}' but got '${rootNode.type}'`
+          });
+        }
+      }
+    } else if (xlrNode.type === "conditional") {
+      const resolvedType = resolveConditional(xlrNode);
+      if (resolvedType === xlrNode) {
+        throw Error(`Unable to resolve conditional type at runtime: ${xlrNode.name}`);
+      }
+      validationIssues.push(...this.validateType(rootNode, resolvedType));
+    } else {
+      throw Error(`Unknown type ${xlrNode.type}`);
+    }
+    return validationIssues;
+  }
+  validateTemplate(node, xlrNode) {
+    if (node.type !== "string") {
+      return {
+        type: "type",
+        node: node.parent,
+        message: `Expected type '${xlrNode.type}' but got '${typeof node}'`
+      };
+    }
+    const regex = this.getRegex(xlrNode.format);
+    const valid = regex.exec(node.value);
+    if (!valid) {
+      return {
+        type: "value",
+        node: node.parent,
+        message: `Does not match expected format: ${xlrNode.format}`
+      };
+    }
+  }
+  validateArray(rootNode, xlrNode) {
+    var _a;
+    const issues = [];
+    (_a = rootNode.children) == null ? void 0 : _a.forEach((child) => issues.push(...this.validateType(child, xlrNode.elementType)));
+    return issues;
+  }
+  validateObject(xlrNode, node) {
+    const issues = [];
+    const objectProps = makePropertyMap(node);
+    for (const prop in xlrNode.properties) {
+      const expectedType = xlrNode.properties[prop];
+      const valueNode = objectProps.get(prop);
+      if (expectedType.required && valueNode === void 0) {
+        issues.push({
+          type: "missing",
+          node,
+          message: `Property '${prop}' missing from type '${xlrNode.name}'`
+        });
+      }
+      if (valueNode) {
+        issues.push(...this.validateType(valueNode, expectedType.node));
+      }
+    }
+    const extraKeys = Array.from(objectProps.keys()).filter((key) => xlrNode.properties[key] === void 0);
+    if (xlrNode.additionalProperties === false && extraKeys.length > 0) {
+      issues.push({
+        type: "value",
+        node,
+        message: `Unexpected properties on '${xlrNode.name}': ${extraKeys.join(", ")}`
+      });
+    } else {
+      issues.push(...extraKeys.flatMap((key) => this.validateType(objectProps.get(key), xlrNode.additionalProperties)));
+    }
+    return issues;
+  }
+  validateLiteralType(expectedType, literalType) {
+    switch (expectedType.type) {
+      case "boolean":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "boolean";
+      case "number":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "number";
+      case "string":
+        if (expectedType.const) {
+          return expectedType.const === literalType.value;
+        }
+        return typeof literalType.value === "string";
+      case "null":
+        return literalType.value === "null";
+      case "never":
+        return literalType === void 0;
+      case "any":
+        return literalType !== void 0;
+      case "unknown":
+        return literalType !== void 0;
+      case "undefined":
+        return true;
+      default:
+        return false;
+    }
+  }
+  getRefType(ref) {
+    let refName = ref.ref;
+    const { genericArguments } = ref;
+    if (refName.indexOf("<") > 0) {
+      [refName] = refName.split("<");
+    }
+    const actualType = this.typeMap.get(refName);
+    const genericMap = new Map();
+    if (genericArguments && isGenericNodeType(actualType)) {
+      actualType.genericTokens.forEach((token, index) => {
+        var _a, _b;
+        genericMap.set(token.symbol, (_b = (_a = genericArguments[index]) != null ? _a : token.default) != null ? _b : token.constraints);
+      });
+    }
+    return fillInGenerics(actualType, genericMap);
+  }
+  getRegex(expString) {
+    if (this.regexCache.has(expString)) {
+      return this.regexCache.get(expString);
+    }
+    const exp = new RegExp(expString);
+    this.regexCache.set(expString, exp);
+    return exp;
+  }
+  computeIntersectionType(types) {
+    let firstElement = types[0];
+    let effectiveType;
+    if (firstElement.type === "ref") {
+      firstElement = this.getRefType(firstElement);
+    }
+    if (firstElement.type === "and") {
+      effectiveType = this.computeIntersectionType(firstElement.and);
+    } else if (firstElement.type !== "or" && firstElement.type !== "object") {
+      throw new Error(`Can't compute a union with a non-object type ${firstElement.type} (${firstElement.name})`);
+    } else {
+      effectiveType = firstElement;
+    }
+    types.slice(1).forEach((type) => {
+      let typeToApply = type;
+      if (type.type === "ref") {
+        typeToApply = this.getRefType(type);
+      }
+      if (typeToApply.type === "and") {
+        typeToApply = this.computeIntersectionType([type, effectiveType]);
+      }
+      if (typeToApply.type === "object") {
+        if (effectiveType.type === "object") {
+          effectiveType = this.computeEffectiveObject(effectiveType, typeToApply);
+        } else {
+          effectiveType = __spreadProps(__spreadValues({}, effectiveType), {
+            or: effectiveType.or.map((y) => this.computeIntersectionType([y, typeToApply]))
+          });
+        }
+      } else if (typeToApply.type === "or") {
+        if (effectiveType.type === "object") {
+          effectiveType = __spreadProps(__spreadValues({}, typeToApply), {
+            or: typeToApply.or.map((y) => this.computeIntersectionType([y, effectiveType]))
+          });
+        } else {
+          throw new Error("unimplemented operation or x or projection");
+        }
+      } else {
+        throw new Error(`Can't compute a union with a non-object type ${typeToApply.type} (${typeToApply.name})`);
+      }
+    });
+    return effectiveType;
+  }
+  computeEffectiveObject(base, operand, errorOnOverlap = true) {
+    var _a, _b;
+    const newObject = __spreadProps(__spreadValues({}, base), {
+      name: `${base.name} & ${operand.name}`,
+      description: `Effective type combining ${base.name} and ${operand.name}`
+    });
+    for (const property in operand.properties) {
+      if (newObject.properties[property] !== void 0 && newObject.properties[property].node.type !== operand.properties[property].node.type && errorOnOverlap) {
+        throw new Error(`Can't compute effective type for ${(_a = base.name) != null ? _a : "object literal"} and ${(_b = operand.name) != null ? _b : "object literal"} because of conflicting properties ${property}`);
+      }
+      newObject.properties[property] = operand.properties[property];
+    }
+    if (newObject.additionalProperties && operand.additionalProperties) {
+      newObject.additionalProperties = {
+        type: "and",
+        and: [newObject.additionalProperties, operand.additionalProperties]
+      };
+    } else if (operand.additionalProperties) {
+      newObject.additionalProperties = operand.additionalProperties;
+    }
+    return newObject;
+  }
+}
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+class XLRSDK {
+  constructor(customRegistry) {
+    this.registry = customRegistry != null ? customRegistry : new BasicXLRRegistry();
+    this.validator = new XLRValidator(this.registry);
+    this.tsWriter = new TSWriter();
+  }
+  loadDefinitionsFromDisk(inputPath, filters, transforms) {
+    var _a;
+    const manifest = JSON.parse(fs.readFileSync(path.join(inputPath, "xlr", "manifest.json")).toString(), (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (key === "capabilities") {
+          return new Map(Object.entries(value));
+        }
+      }
+      return value;
+    });
+    (_a = manifest.capabilities) == null ? void 0 : _a.forEach((capabilityList, capabilityName) => {
+      if ((filters == null ? void 0 : filters.capabilityFilter) && capabilityName.match(filters == null ? void 0 : filters.capabilityFilter))
+        return;
+      capabilityList.forEach((extensionName) => {
+        if (!(filters == null ? void 0 : filters.typeFilter) || !extensionName.match(filters == null ? void 0 : filters.typeFilter)) {
+          const cType = JSON.parse(fs.readFileSync(path.join(inputPath, "xlr", `${extensionName}.json`)).toString());
+          transforms == null ? void 0 : transforms.forEach((transform) => transform(cType, capabilityName));
+          const resolvedType = fillInGenerics(cType);
+          this.registry.add(resolvedType, manifest.pluginName, capabilityName);
+        }
+      });
+    });
+  }
+  loadDefinitionsFromModule(inputPath, filters, transforms) {
+    return __async(this, null, function* () {
+      var _a;
+      const importManifest = yield import(path.join(inputPath, "xlr", "manifest.js"));
+      const manifest = importManifest.default;
+      (_a = Object.keys(manifest.capabilities)) == null ? void 0 : _a.forEach((capabilityName) => {
+        if ((filters == null ? void 0 : filters.capabilityFilter) && capabilityName.match(filters == null ? void 0 : filters.capabilityFilter))
+          return;
+        const capabilityList = manifest.capabilities[capabilityName];
+        capabilityList.forEach((extension) => {
+          if (!(filters == null ? void 0 : filters.typeFilter) || !extension.name.match(filters == null ? void 0 : filters.typeFilter)) {
+            transforms == null ? void 0 : transforms.forEach((transform) => transform(extension, extension.name));
+            const resolvedType = fillInGenerics(extension);
+            this.registry.add(resolvedType, manifest.pluginName, extension.name);
+          }
+        });
+      });
+    });
+  }
+  getType(id) {
+    return this.registry.get(id);
+  }
+  hasType(id) {
+    return this.registry.has(id);
+  }
+  listTypes(filters) {
+    return this.registry.list(filters);
+  }
+  validate(typeName, rootNode) {
+    const xlr = this.registry.get(typeName);
+    if (!xlr) {
+      throw new Error(`Type ${typeName} does not exist in registry, can't validate`);
+    }
+    return this.validator.validateType(rootNode, xlr);
+  }
+  exportRegistry(exportType, importMap, filters, transforms) {
+    const typesToExport = this.registry.list(filters).map((type) => {
+      transforms == null ? void 0 : transforms.forEach((transformFunction) => {
+        var _a;
+        return transformFunction(type, (_a = this.registry.info(type.name)) == null ? void 0 : _a.capability);
+      });
+      return type;
+    });
+    if (exportType === "TypeScript") {
+      const outputString = this.exportToTypeScript(typesToExport, importMap);
+      return [["out.d.ts", outputString]];
+    }
+    throw new Error(`Unknown export format ${exportType}`);
+  }
+  exportToTypeScript(typesToExport, importMap) {
+    const referencedImports = new Set();
+    const exportedTypes = new Map();
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    let resultFile = ts.createSourceFile("output.d.ts", "", ts.ScriptTarget.ES2017, false, ts.ScriptKind.TS);
+    typesToExport.forEach((typeNode) => {
+      const { type, referencedTypes, additionalTypes } = this.tsWriter.convertNamedType(typeNode);
+      exportedTypes.set(typeNode.name, type);
+      additionalTypes == null ? void 0 : additionalTypes.forEach((additionalType, name) => exportedTypes.set(name, additionalType));
+      referencedTypes == null ? void 0 : referencedTypes.forEach((referencedType) => referencedImports.add(referencedType));
+    });
+    const typesToPrint = [];
+    exportedTypes.forEach((type) => typesToPrint.push(printer.printNode(ts.EmitHint.Unspecified, type, resultFile)));
+    importMap.forEach((imports, packageName) => {
+      const applicableImports = imports.filter((i) => referencedImports.has(i));
+      resultFile = ts.factory.updateSourceFile(resultFile, [
+        ts.factory.createImportDeclaration(void 0, void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(applicableImports.map((i) => ts.factory.createImportSpecifier(void 0, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(packageName)),
+        ...resultFile.statements
+      ]);
+    });
+    const headerText = printer.printFile(resultFile);
+    const nodeText = typesToPrint.join("\n");
+    return `${headerText}
+${nodeText}`;
+  }
+}
+
+export { BasicXLRRegistry, XLRSDK };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@player-tools/xlr-sdk",
+  "version": "0.0.2-next.0",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "typescript": "4.4.4"
+  },
+  "dependencies": {
+    "@player-tools/xlr": "0.0.2-next.0",
+    "@player-tools/xlr-utils": "0.0.2-next.0",
+    "@player-tools/xlr-converters": "0.0.2-next.0",
+    "jsonc-parser": "^2.3.1",
+    "@types/node": "^16.11.12",
+    "@types/fs-extra": "^9.0.13",
+    "fs-extra": "^10.0.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"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './sdk';
+export * from './types';
+export * from './registry';

package/src/registry/basic-registry.ts

@@ -0,0 +1,83 @@
+import type { NamedType, NodeType } from '@player-tools/xlr';
+import type { XLRRegistry, Filters, TypeMetadata } from './types';
+
+/**
+ * Basic example of a XLRs Registry
+ */
+export class BasicXLRRegistry implements XLRRegistry {
+  private typeMap: Map<string, NamedType<NodeType>>;
+  private pluginMap: Map<string, Map<string, Array<string>>>;
+  private infoMap: Map<string, TypeMetadata>;
+
+  constructor() {
+    this.typeMap = new Map();
+    this.pluginMap = new Map();
+    this.infoMap = new Map();
+  }
+
+  /** Returns a copy of the XLR to guard against unexpected type modification */
+  get(id: string): NamedType<NodeType> | undefined {
+    const value = this.typeMap.get(id);
+    return value ? { ...value } : undefined;
+  }
+
+  add(type: NamedType<NodeType>, plugin: string, capability: string): void {
+    this.typeMap.set(type.name, type);
+    this.infoMap.set(type.name, { plugin, capability });
+
+    if (!this.pluginMap.has(plugin)) {
+      this.pluginMap.set(plugin, new Map());
+    }
+
+    const pluginsCapabilities = this.pluginMap.get(plugin) as Map<
+      string,
+      Array<string>
+    >;
+
+    if (!pluginsCapabilities.has(capability)) {
+      pluginsCapabilities.set(capability, []);
+    }
+
+    const providedCapabilities = pluginsCapabilities.get(
+      capability
+    ) as string[];
+    providedCapabilities.push(type.name);
+  }
+
+  has(id: string): boolean {
+    return this.typeMap.has(id);
+  }
+
+  list(filterArgs?: Filters): NamedType<NodeType>[] {
+    const validTypes: Array<string> = [];
+
+    this.pluginMap.forEach((manifest, pluginName) => {
+      if (
+        !filterArgs?.pluginFilter ||
+        !pluginName.match(filterArgs.pluginFilter)
+      ) {
+        manifest.forEach((types, capabilityName) => {
+          if (
+            !filterArgs?.capabilityFilter ||
+            !capabilityName.match(filterArgs.capabilityFilter)
+          ) {
+            types.forEach((type) => {
+              if (
+                !filterArgs?.typeFilter ||
+                !type.match(filterArgs.typeFilter)
+              ) {
+                validTypes.push(type);
+              }
+            });
+          }
+        });
+      }
+    });
+
+    return validTypes.map((type) => this.get(type) as NamedType);
+  }
+
+  info(id: string): TypeMetadata | undefined {
+    return this.infoMap.get(id);
+  }
+}

package/src/registry/index.ts

@@ -0,0 +1,2 @@
+export * from './basic-registry';
+export * from './types';

package/src/registry/types.ts

@@ -0,0 +1,28 @@
+import type { NamedType } from '@player-tools/xlr';
+
+export interface Filters {
+  /** filter based on plugin name */
+  pluginFilter?: string | RegExp;
+
+  /** filter based on capability name */
+  capabilityFilter?: string | RegExp;
+
+  /** filter based on type name */
+  typeFilter?: string | RegExp;
+}
+
+export interface TypeMetadata {
+  /** The Plugin the Type comes from */
+  plugin: string;
+
+  /** The Capability of the Type */
+  capability: string;
+}
+
+export interface XLRRegistry {
+  get(id: string): NamedType | undefined;
+  add(type: NamedType, from: string, capability: string): void;
+  has(id: string): boolean;
+  list(filterArgs?: Filters): Array<NamedType>;
+  info(id: string): TypeMetadata | undefined;
+}