@player-lang/json-language-service 0.0.2-next.0

package/src/xlr/__tests__/__snapshots__/transform.test.ts.snap

@@ -0,0 +1,390 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Transform Tests > AssetWrapperOrSwitch Transform 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "Mock Asset for test",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyAsset",
+    },
+  ],
+  "name": "MockAsset",
+  "properties": {
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "primaryChild": {
+      "node": {
+        "description": "A text-like asset for the action's label",
+        "genericArguments": [
+          {
+            "ref": "AnyAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapperOrSwitch<AnyAsset>",
+        "title": "ActionAsset.label",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "secondaryChildren": {
+      "node": {
+        "elementType": {
+          "ref": "Asset",
+          "type": "ref",
+        },
+        "type": "array",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "const": "mock",
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "title": "Asset.type",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "value": {
+      "node": {
+        "description": "The transition value of the action in the state machine",
+        "title": "MockAsset.value",
+        "type": "string",
+      },
+      "required": false,
+    },
+  },
+  "source": "transform.test.ts",
+  "title": "MockAsset",
+  "type": "object",
+}
+`;
+
+exports[`Transform Tests > CommonProps Transform 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "Mock Asset for test",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyAsset",
+    },
+  ],
+  "name": "MockAsset",
+  "properties": {
+    "_comment": {
+      "node": {
+        "description": "Adds a comment for the given node",
+        "type": "string",
+      },
+      "required": false,
+    },
+    "applicability": {
+      "node": {
+        "description": "Evaluate the given expression (or boolean) and if falsy, remove this node from the tree. This is re-computed for each change in the data-model",
+        "name": "Applicability",
+        "or": [
+          {
+            "type": "boolean",
+          },
+          {
+            "ref": "Expression",
+            "type": "ref",
+          },
+        ],
+        "type": "or",
+      },
+      "required": false,
+    },
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "primaryChild": {
+      "node": {
+        "description": "A text-like asset for the action's label",
+        "genericArguments": [
+          {
+            "ref": "AnyAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyAsset>",
+        "title": "ActionAsset.label",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "secondaryChildren": {
+      "node": {
+        "elementType": {
+          "ref": "Asset",
+          "type": "ref",
+        },
+        "type": "array",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "const": "mock",
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "title": "Asset.type",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "value": {
+      "node": {
+        "description": "The transition value of the action in the state machine",
+        "title": "MockAsset.value",
+        "type": "string",
+      },
+      "required": false,
+    },
+  },
+  "source": "transform.test.ts",
+  "title": "MockAsset",
+  "type": "object",
+}
+`;
+
+exports[`Transform Tests > applyTemplateProperty Transform 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "Mock Asset for test",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyAsset",
+    },
+  ],
+  "name": "MockAsset",
+  "properties": {
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "primaryChild": {
+      "node": {
+        "description": "A text-like asset for the action's label",
+        "genericArguments": [
+          {
+            "ref": "AnyAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyAsset>",
+        "title": "ActionAsset.label",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "secondaryChildren": {
+      "node": {
+        "elementType": {
+          "ref": "Asset",
+          "type": "ref",
+        },
+        "type": "array",
+      },
+      "required": false,
+    },
+    "template": {
+      "node": {
+        "description": "A list of templates to process for this node",
+        "elementType": {
+          "genericArguments": [
+            {
+              "ref": "Asset",
+              "type": "ref",
+            },
+            {
+              "const": "secondaryChildren",
+              "type": "string",
+            },
+          ],
+          "ref": "Template<Asset, "secondaryChildren">",
+          "type": "ref",
+        },
+        "type": "array",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "const": "mock",
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "title": "Asset.type",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "value": {
+      "node": {
+        "description": "The transition value of the action in the state machine",
+        "title": "MockAsset.value",
+        "type": "string",
+      },
+      "required": false,
+    },
+  },
+  "source": "transform.test.ts",
+  "title": "MockAsset",
+  "type": "object",
+}
+`;
+
+exports[`Transform Tests > applyValueRefs Transform 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "Mock Asset for test",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyAsset",
+    },
+  ],
+  "name": "MockAsset",
+  "properties": {
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "primaryChild": {
+      "node": {
+        "description": "A text-like asset for the action's label",
+        "genericArguments": [
+          {
+            "ref": "AnyAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyAsset>",
+        "title": "ActionAsset.label",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "secondaryChildren": {
+      "node": {
+        "elementType": {
+          "ref": "Asset",
+          "type": "ref",
+        },
+        "type": "array",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "or": [
+          {
+            "const": "mock",
+            "description": "The asset type determines the semantics of how a user interacts with a page",
+            "title": "Asset.type",
+            "type": "string",
+          },
+          {
+            "ref": "ExpressionRef",
+            "type": "ref",
+          },
+          {
+            "ref": "BindingRef",
+            "type": "ref",
+          },
+        ],
+        "type": "or",
+      },
+      "required": true,
+    },
+    "value": {
+      "node": {
+        "description": "The transition value of the action in the state machine",
+        "or": [
+          {
+            "description": "The transition value of the action in the state machine",
+            "title": "MockAsset.value",
+            "type": "string",
+          },
+          {
+            "ref": "ExpressionRef",
+            "type": "ref",
+          },
+          {
+            "ref": "BindingRef",
+            "type": "ref",
+          },
+        ],
+        "type": "or",
+      },
+      "required": false,
+    },
+  },
+  "source": "transform.test.ts",
+  "title": "MockAsset",
+  "type": "object",
+}
+`;

package/src/xlr/__tests__/transform.test.ts

@@ -0,0 +1,108 @@
+import { test, expect, describe, beforeEach } from "vitest";
+import type { NamedTypeWithGenerics, ObjectType } from "@xlr-lib/xlr";
+import {
+  applyCommonProps,
+  applyAssetWrapperOrSwitch,
+  applyValueRefs,
+  applyTemplateProperty,
+} from "../index";
+
+describe("Transform Tests", () => {
+  let MockAsset: NamedTypeWithGenerics<ObjectType>;
+
+  beforeEach(() => {
+    MockAsset = {
+      name: "MockAsset",
+      type: "object",
+      source: "transform.test.ts",
+      properties: {
+        id: {
+          required: true,
+          node: {
+            type: "string",
+            title: "Asset.id",
+            description: "Each asset requires a unique id per view",
+          },
+        },
+        type: {
+          required: true,
+          node: {
+            type: "string",
+            const: "mock",
+            title: "Asset.type",
+            description:
+              "The asset type determines the semantics of how a user interacts with a page",
+          },
+        },
+        value: {
+          required: false,
+          node: {
+            type: "string",
+            title: "MockAsset.value",
+            description:
+              "The transition value of the action in the state machine",
+          },
+        },
+        primaryChild: {
+          required: true,
+          node: {
+            type: "ref",
+            ref: "AssetWrapper<AnyAsset>",
+            genericArguments: [
+              {
+                type: "ref",
+                ref: "AnyAsset",
+              },
+            ],
+            title: "ActionAsset.label",
+            description: "A text-like asset for the action's label",
+          },
+        },
+        secondaryChildren: {
+          required: false,
+          node: {
+            type: "array",
+            elementType: {
+              type: "ref",
+              ref: "Asset",
+            },
+          },
+        },
+      },
+      additionalProperties: {
+        type: "unknown",
+      },
+      title: "MockAsset",
+      description: "Mock Asset for test",
+      genericTokens: [
+        {
+          symbol: "AnyAsset",
+          constraints: {
+            type: "ref",
+            ref: "Asset",
+          },
+          default: {
+            type: "ref",
+            ref: "Asset",
+          },
+        },
+      ],
+    };
+  });
+
+  test("CommonProps Transform", () => {
+    expect(applyCommonProps(MockAsset, "Assets")).toMatchSnapshot();
+  });
+
+  test("AssetWrapperOrSwitch Transform", () => {
+    expect(applyAssetWrapperOrSwitch(MockAsset, "Assets")).toMatchSnapshot();
+  });
+
+  test("applyValueRefs Transform", () => {
+    expect(applyValueRefs(MockAsset, "Assets")).toMatchSnapshot();
+  });
+
+  test("applyTemplateProperty Transform", () => {
+    expect(applyTemplateProperty(MockAsset, "Assets")).toMatchSnapshot();
+  });
+});

package/src/xlr/index.ts

@@ -0,0 +1,3 @@
+export * from "./registry";
+export * from "./service";
+export * from "./transforms";

package/src/xlr/registry.ts

@@ -0,0 +1,99 @@
+import type { Filters, TypeMetadata } from "@xlr-lib/xlr-sdk";
+import { BasicXLRRegistry } from "@xlr-lib/xlr-sdk";
+import type { NamedType, NodeType } from "@xlr-lib/xlr";
+
+/**
+ * Player specific implementation of a XLRs Registry
+ */
+export class PlayerXLRRegistry extends BasicXLRRegistry {
+  /** Keeps the mapping of how a type is referenced by Player to the underlying XLR */
+  private registrationMap: Map<string, string | Array<string>>;
+
+  constructor() {
+    super();
+    this.registrationMap = new Map();
+  }
+
+  get(id: string): NamedType<NodeType> | undefined {
+    const realNames = this.registrationMap.get(id);
+    if (realNames === undefined) {
+      return undefined;
+    }
+
+    if (Array.isArray(realNames)) {
+      return {
+        name: `${id}PartialMatchType`,
+        source: "registry.ts",
+        type: "or",
+        or: realNames.map(
+          (partialMatchID) => super.get(partialMatchID) as NamedType,
+        ),
+      };
+    }
+
+    return super.get(realNames);
+  }
+
+  add(type: NamedType<NodeType>, plugin: string, capability: string): void {
+    let registeredName = type.name;
+    // Figure out how the Asset/View will be referenced from the type argument that will fill in Asset
+    if (
+      (capability === "Assets" || capability === "Views") &&
+      type.type === "object" &&
+      type.extends?.genericArguments?.[0]?.type === "string" &&
+      type.extends?.genericArguments?.[0]?.const
+    ) {
+      this.registrationMap.set(registeredName, type.name);
+      registeredName = type.extends.genericArguments[0].const;
+    }
+
+    if (this.registrationMap.has(registeredName)) {
+      const current = this.registrationMap.get(registeredName) as
+        | string
+        | string[];
+      if (Array.isArray(current)) {
+        current.push(registeredName);
+      } else {
+        this.registrationMap.set(registeredName, [current, type.name]);
+      }
+    } else {
+      this.registrationMap.set(registeredName, type.name);
+    }
+
+    super.add(type, plugin, capability);
+  }
+
+  has(id: string): boolean {
+    return this.registrationMap.has(id);
+  }
+
+  list(filterArgs?: Filters): NamedType<NodeType>[] {
+    return super.list(filterArgs);
+  }
+
+  info(id: string): TypeMetadata | undefined {
+    const realNames = this.registrationMap.get(id);
+    if (realNames === undefined) {
+      return undefined;
+    }
+
+    if (Array.isArray(realNames)) {
+      const metaDataArrays = realNames.map((name) => super.info(name));
+      const firstElement = metaDataArrays[0];
+      const equal = metaDataArrays.every(
+        (metaData) =>
+          metaData?.plugin === firstElement?.plugin &&
+          metaData?.capability === firstElement?.capability,
+      );
+      if (equal) {
+        return firstElement;
+      }
+
+      throw Error(
+        `Error: can't determine accurate info for type ${id} as it is provided by multiple plugins/capabilities`,
+      );
+    }
+
+    return super.info(realNames);
+  }
+}