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

package/README.md

@@ -0,0 +1,10 @@
+# @player-tools/xlr-sdk
+
+Unified interface for working with XLRs. Abstracts away needing to know how they are packaged or where they are sourced from. Current operations supported: 
+
+- Load
+- Export
+  - Typescript
+- Validate
+
+Also exposes functionality to create your own XLR Registry to manage how the SDK stores loaded types. 

package/dist/index.cjs.js

@@ -0,0 +1,509 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var xlrUtils = require('@player-tools/xlr-utils');
+var xlrConverters = require('@player-tools/xlr-converters');
+var fs = require('fs');
+var path = require('path');
+var ts = require('typescript');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+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 fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+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 (xlrUtils.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 = xlrUtils.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 = xlrUtils.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 && xlrUtils.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 xlrUtils.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 xlrConverters.TSWriter();
+  }
+  loadDefinitionsFromDisk(inputPath, filters, transforms) {
+    var _a;
+    const manifest = JSON.parse(fs__default["default"].readFileSync(path__default["default"].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__default["default"].readFileSync(path__default["default"].join(inputPath, "xlr", `${extensionName}.json`)).toString());
+          transforms == null ? void 0 : transforms.forEach((transform) => transform(cType, capabilityName));
+          const resolvedType = xlrUtils.fillInGenerics(cType);
+          this.registry.add(resolvedType, manifest.pluginName, capabilityName);
+        }
+      });
+    });
+  }
+  loadDefinitionsFromModule(inputPath, filters, transforms) {
+    return __async(this, null, function* () {
+      var _a;
+      const importManifest = yield (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(path__default["default"].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 = xlrUtils.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__default["default"].createPrinter({ newLine: ts__default["default"].NewLineKind.LineFeed });
+    let resultFile = ts__default["default"].createSourceFile("output.d.ts", "", ts__default["default"].ScriptTarget.ES2017, false, ts__default["default"].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__default["default"].EmitHint.Unspecified, type, resultFile)));
+    importMap.forEach((imports, packageName) => {
+      const applicableImports = imports.filter((i) => referencedImports.has(i));
+      resultFile = ts__default["default"].factory.updateSourceFile(resultFile, [
+        ts__default["default"].factory.createImportDeclaration(void 0, void 0, ts__default["default"].factory.createImportClause(false, void 0, ts__default["default"].factory.createNamedImports(applicableImports.map((i) => ts__default["default"].factory.createImportSpecifier(void 0, ts__default["default"].factory.createIdentifier(i))))), ts__default["default"].factory.createStringLiteral(packageName)),
+        ...resultFile.statements
+      ]);
+    });
+    const headerText = printer.printFile(resultFile);
+    const nodeText = typesToPrint.join("\n");
+    return `${headerText}
+${nodeText}`;
+  }
+}
+
+exports.BasicXLRRegistry = BasicXLRRegistry;
+exports.XLRSDK = XLRSDK;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+import { Node } from 'jsonc-parser';
+import { NamedType, NodeType, TransformFunction } from '@player-tools/xlr';
+
+interface ValidationError {
+    /** Error message text */
+    message: string;
+    /** JSONC node that the error originates from */
+    node: Node;
+    /** Rough categorization of the error type */
+    type: 'type' | 'missing' | 'unknown' | 'value' | 'unexpected';
+}
+/** Support Export Formats */
+declare type ExportTypes = 'TypeScript';
+
+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;
+}
+interface TypeMetadata {
+    /** The Plugin the Type comes from */
+    plugin: string;
+    /** The Capability of the Type */
+    capability: string;
+}
+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;
+}
+
+/**
+ * Basic example of a XLRs Registry
+ */
+declare class BasicXLRRegistry implements XLRRegistry {
+    private typeMap;
+    private pluginMap;
+    private infoMap;
+    constructor();
+    /** Returns a copy of the XLR to guard against unexpected type modification */
+    get(id: string): NamedType<NodeType> | undefined;
+    add(type: NamedType<NodeType>, plugin: string, capability: string): void;
+    has(id: string): boolean;
+    list(filterArgs?: Filters): NamedType<NodeType>[];
+    info(id: string): TypeMetadata | undefined;
+}
+
+/**
+ * Abstraction for interfacing with XLRs making it more approachable to use without understanding the inner workings of the types and how they are packaged
+ */
+declare class XLRSDK {
+    private registry;
+    private validator;
+    private tsWriter;
+    constructor(customRegistry?: XLRRegistry);
+    loadDefinitionsFromDisk(inputPath: string, filters?: Omit<Filters, 'pluginFilter'>, transforms?: Array<TransformFunction>): void;
+    loadDefinitionsFromModule(inputPath: string, filters?: Omit<Filters, 'pluginFilter'>, transforms?: Array<TransformFunction>): Promise<void>;
+    getType(id: string): NamedType<NodeType> | undefined;
+    hasType(id: string): boolean;
+    listTypes(filters?: Filters): NamedType<NodeType>[];
+    validate(typeName: string, rootNode: Node): ValidationError[];
+    /**
+     * Exports the types loaded into the registry to the specified format
+     *
+     * @param exportType - what format to export as
+     * @param importMap - a map of primitive packages to types exported from that package to add import statements
+     * @param filters - filter out plugins/capabilities/types you don't want to export
+     * @param transforms - transforms to apply to types before exporting them
+     * @returns [filename, content][] - Tuples of filenames and content to write
+     */
+    exportRegistry(exportType: ExportTypes, importMap: Map<string, string[]>, filters?: Filters, transforms?: Array<TransformFunction>): [string, string][];
+    private exportToTypeScript;
+}
+
+export { BasicXLRRegistry, ExportTypes, Filters, TypeMetadata, ValidationError, XLRRegistry, XLRSDK };