@xlr-lib/xlr-sdk 0.2.0--canary.2.131 → 1.0.0

package/src/__tests__/sdk.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe } from "vitest";
-import type { NamedType, TransformFunction, OrType } from "@xlr-lib/xlr";
+import type { NamedType, OrType, ObjectType } from "@xlr-lib/xlr";
 import { parseTree } from "jsonc-parser";
 import { Types, ReferenceAssetsWebPluginManifest } from "@xlr-lib/static-xlrs";
 import type { Filters } from "../registry";
@@ -70,6 +70,19 @@ describe("Object Recall", () => {
 
     expect(sdk.getType("InputAsset")).toMatchSnapshot();
   });
+
+  test("Test Correct Generic Cascading", () => {
+    const sdk = new XLRSDK();
+    sdk.loadDefinitionsFromModule(Types);
+    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
+    const Flow = sdk.getType("Flow") as ObjectType;
+    const Schema = Flow.properties["schema"].node as ObjectType;
+    const Node = Schema.additionalProperties as ObjectType;
+    const DataTypes = Node.additionalProperties as OrType;
+    const DataType = DataTypes.or[0] as ObjectType;
+    const df = DataType.properties["default"].node;
+    expect(df.type).toBe("unknown");
+  });
 });
 
 describe("Validation", () => {
@@ -142,85 +155,6 @@ describe("Validation", () => {
   });
 });
 
-describe("Export Test", () => {
-  test("Exports Typescript types", () => {
-    const importMap = new Map([
-      [
-        "@player-ui/types",
-        ["Expression", "Asset", "Binding", "AssetWrapper", "Schema.DataType"],
-      ],
-    ]);
-
-    const sdk = new XLRSDK();
-    sdk.loadDefinitionsFromModule(Types);
-    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
-    const results = sdk.exportRegistry("TypeScript", importMap);
-    expect(results[0][0]).toBe("out.d.ts");
-    expect(results[0][1]).toMatchSnapshot();
-  });
-
-  test("Exports Typescript Types With Filters", () => {
-    const importMap = new Map([
-      [
-        "@player-ui/types",
-        ["Expression", "Asset", "Binding", "AssetWrapper", "Schema.DataType"],
-      ],
-    ]);
-
-    const sdk = new XLRSDK();
-    sdk.loadDefinitionsFromModule(Types);
-    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
-    const results = sdk.exportRegistry("TypeScript", importMap, {
-      typeFilter: "Transformed",
-      pluginFilter: "Types",
-    });
-    expect(results[0][0]).toBe("out.d.ts");
-    expect(results[0][1]).toMatchSnapshot();
-  });
-
-  test("Exports Typescript Types With Transforms", () => {
-    const importMap = new Map([
-      [
-        "@player-ui/types",
-        ["Expression", "Asset", "Binding", "AssetWrapper", "Schema.DataType"],
-      ],
-    ]);
-
-    /**
-     *
-     */
-    const transformFunction: TransformFunction = (input, capability) => {
-      if (capability === "Assets") {
-        const ret = { ...input };
-        if (ret.type === "object") {
-          ret.properties.transformed = {
-            required: false,
-            node: { type: "boolean", const: true },
-          };
-        }
-
-        return ret;
-      }
-
-      return input;
-    };
-
-    const sdk = new XLRSDK();
-    sdk.loadDefinitionsFromModule(Types);
-    sdk.loadDefinitionsFromModule(ReferenceAssetsWebPluginManifest);
-    const results = sdk.exportRegistry(
-      "TypeScript",
-      importMap,
-      {
-        pluginFilter: "Types",
-      },
-      [transformFunction],
-    );
-    expect(results[0][0]).toBe("out.d.ts");
-    expect(results[0][1]).toMatchSnapshot();
-  });
-});
-
 describe("Or Type Validation", () => {
   test("Outputs helpful type error messages", () => {
     const mockAsset = parseTree(`

package/src/sdk.ts

@@ -8,7 +8,6 @@ import type {
   TransformFunction,
   TSManifest,
 } from "@xlr-lib/xlr";
-import type { TopLevelDeclaration } from "@xlr-lib/xlr-utils";
 import {
   computeEffectiveObject,
   resolveConditional,
@@ -16,14 +15,11 @@ import {
 } from "@xlr-lib/xlr-utils";
 import { fillInGenerics } from "@xlr-lib/xlr-utils";
 import type { Node } from "jsonc-parser";
-import { TSWriter } from "@xlr-lib/xlr-converters";
 import fs from "fs";
 import path from "path";
-import ts from "typescript";
 
 import type { XLRRegistry, Filters } from "./registry";
 import { BasicXLRRegistry } from "./registry";
-import type { ExportTypes } from "./types";
 import { XLRValidator } from "./validator";
 import { TransformFunctionMap, xlrTransformWalker } from "./utils";
 
@@ -40,14 +36,12 @@ export interface GetTypeOptions {
 export class XLRSDK {
   private registry: XLRRegistry;
   private validator: XLRValidator;
-  private tsWriter: TSWriter;
   private computedNodeCache: Map<string, NodeType>;
   private externalTransformFunctions: Map<string, TransformFunction>;
 
   constructor(customRegistry?: XLRRegistry) {
     this.registry = customRegistry ?? new BasicXLRRegistry();
     this.validator = new XLRValidator(this.getType.bind(this));
-    this.tsWriter = new TSWriter();
     this.computedNodeCache = new Map();
     this.externalTransformFunctions = new Map();
   }
@@ -265,43 +259,6 @@ export class XLRSDK {
     return this.validator.validateType(rootNode, type);
   }
 
-  /**
-   * 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
-   */
-  public exportRegistry(
-    exportType: ExportTypes,
-    importMap: Map<string, string[]>,
-    filters?: Filters,
-    transforms?: Array<TransformFunction>
-  ): [string, string][] {
-    const typesToExport = this.registry.list(filters).map((type) => {
-      const effectiveType =
-        transforms?.reduce(
-          (typeAccumulator: NamedType<NodeType>, transformFn) =>
-            transformFn(
-              typeAccumulator,
-              this.registry.info(type.name)?.capability as string
-            ) as NamedType<NodeType>,
-          type
-        ) ?? type;
-
-      return effectiveType;
-    });
-
-    if (exportType === "TypeScript") {
-      const outputString = this.exportToTypeScript(typesToExport, importMap);
-      return [["out.d.ts", outputString]];
-    }
-
-    throw new Error(`Unknown export format ${exportType}`);
-  }
-
   /**
    * Transforms a generated XLR node into its final representation by resolving all `extends` properties.
    * If `optimize` is set to true the following operations are also performed:
@@ -311,7 +268,7 @@ export class XLRSDK {
    *  - filing in any remaining generics with their default value
    */
   private resolveType(type: NamedType, optimize = true): NamedType {
-    const resolvedObject = fillInGenerics(type);
+    const resolvedObject = fillInGenerics(type, new Map(), true);
 
     let transformMap: TransformFunctionMap = {
       object: [(objectNode: ObjectType) => {
@@ -391,68 +348,4 @@ export class XLRSDK {
     return xlrTransformWalker(transformMap)(resolvedObject) as NamedType
   }
 
-  private exportToTypeScript(
-    typesToExport: NamedType[],
-    importMap: Map<string, string[]>
-  ): string {
-    const referencedImports: Set<string> = new Set();
-    const exportedTypes: Map<string, TopLevelDeclaration> = new Map();
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-
-    let resultFile = ts.createSourceFile(
-      "output.d.ts",
-      "",
-      ts.ScriptTarget.ES2017,
-      false, // setParentNodes
-      ts.ScriptKind.TS
-    );
-
-    typesToExport.forEach((typeNode) => {
-      const { type, referencedTypes, additionalTypes } =
-        this.tsWriter.convertNamedType(typeNode);
-      exportedTypes.set(typeNode.name, type);
-      additionalTypes?.forEach((additionalType, name) =>
-        exportedTypes.set(name, additionalType)
-      );
-      referencedTypes?.forEach((referencedType) =>
-        referencedImports.add(referencedType)
-      );
-    });
-
-    const typesToPrint: Array<string> = [];
-
-    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(
-          /* modifiers */ undefined,
-          ts.factory.createImportClause(
-            false,
-            undefined,
-            ts.factory.createNamedImports(
-              applicableImports.map((i) =>
-                ts.factory.createImportSpecifier(
-                  false,
-                  undefined,
-                  ts.factory.createIdentifier(i)
-                )
-              )
-            )
-          ),
-          ts.factory.createStringLiteral(packageName)
-        ),
-        ...resultFile.statements,
-      ]);
-    });
-
-    const headerText = printer.printFile(resultFile);
-    const nodeText = typesToPrint.join("\n");
-    return `${headerText}\n${nodeText}`;
-  }
 }

package/src/types.ts

@@ -1,8 +1,5 @@
 import type { Node } from "jsonc-parser";
 
-/** Support Export Formats */
-export type ExportTypes = "TypeScript";
-
 export interface BaseValidationMessage<ErrorType extends string = string> {
   /** Validation Type */
   type: ErrorType;

package/types/sdk.d.ts

@@ -1,7 +1,6 @@
 import type { NamedType, NodeType, TransformFunction, TSManifest } from "@xlr-lib/xlr";
 import type { Node } from "jsonc-parser";
 import type { XLRRegistry, Filters } from "./registry";
-import type { ExportTypes } from "./types";
 export interface GetTypeOptions {
     /** Resolves `extends` fields in objects */
     getRawType?: boolean;
@@ -14,7 +13,6 @@ export interface GetTypeOptions {
 export declare class XLRSDK {
     private registry;
     private validator;
-    private tsWriter;
     private computedNodeCache;
     private externalTransformFunctions;
     constructor(customRegistry?: XLRRegistry);
@@ -87,16 +85,6 @@ export declare class XLRSDK {
      * @returns `Array<ValidationErrors>`
      */
     validateByType(type: NodeType, rootNode: Node): import("./types").ValidationMessage[];
-    /**
-     * 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][];
     /**
      * Transforms a generated XLR node into its final representation by resolving all `extends` properties.
      * If `optimize` is set to true the following operations are also performed:
@@ -106,6 +94,5 @@ export declare class XLRSDK {
      *  - filing in any remaining generics with their default value
      */
     private resolveType;
-    private exportToTypeScript;
 }
 //# sourceMappingURL=sdk.d.ts.map

package/types/types.d.ts

@@ -1,6 +1,4 @@
 import type { Node } from "jsonc-parser";
-/** Support Export Formats */
-export type ExportTypes = "TypeScript";
 export interface BaseValidationMessage<ErrorType extends string = string> {
     /** Validation Type */
     type: ErrorType;