@player-tools/xlr 0.0.2-next.0

package/README.md

@@ -0,0 +1,3 @@
+# @player-tools/xlr
+
+Type definitions for the XLR AST Nodes and other cross package definitions. 

package/dist/index.cjs.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,208 @@
+interface Annotations {
+    /** The name used to reference this type */
+    name?: string;
+    /** The path within a type to this type (may be the same as `name` ) */
+    title?: string;
+    /** The JSDoc string for this type */
+    description?: string;
+    /** The JSDoc `@example` string for this type */
+    examples?: string | Array<string>;
+    /** The JSDoc `@default` string for this type */
+    default?: string;
+    /** The JSDoc `@see` string for this type */
+    see?: string | Array<string>;
+    /** The Typescript comment associated with the type */
+    comment?: string;
+}
+interface TypeMap {
+    /** */
+    and: void;
+    /** */
+    or: void;
+    /** */
+    ref: string;
+    /** */
+    any: unknown;
+    /** */
+    null: null;
+    /** */
+    string: string;
+    /** */
+    number: number;
+    /** */
+    boolean: boolean;
+    /** */
+    object: object;
+    /** */
+    array: Array<unknown>;
+    /** */
+    tuple: Array<unknown>;
+    /** */
+    function: () => unknown;
+    /** */
+    record: Record<string | number | symbol, unknown>;
+    /** */
+    undefined: undefined;
+    /** */
+    never: never;
+    /**  */
+    unknown: unknown;
+}
+interface Const<T> {
+    /** The literal value for the node */
+    const?: T;
+}
+interface Enum<T> {
+    /** The list of enums for the node */
+    enum?: Array<T>;
+}
+declare type CommonTypeInfo<T> = Const<T> & Enum<T>;
+interface TypeNode<Name = string> {
+    /** The type of Node */
+    type: Name;
+}
+declare type AnyType = TypeNode<'any'> & CommonTypeInfo<any> & Annotations;
+declare type UnknownType = TypeNode<'unknown'> & CommonTypeInfo<unknown> & Annotations;
+declare type UndefinedType = TypeNode<'undefined'> & CommonTypeInfo<undefined> & Annotations;
+declare type NullType = TypeNode<'null'> & CommonTypeInfo<null> & Annotations;
+declare type StringType = TypeNode<'string'> & CommonTypeInfo<string> & Annotations;
+declare type NumberType = TypeNode<'number'> & CommonTypeInfo<number> & Annotations;
+declare type BooleanType = TypeNode<'boolean'> & CommonTypeInfo<boolean> & Annotations;
+declare type NeverType = TypeNode<'never'> & CommonTypeInfo<never> & Annotations;
+interface RefNode extends TypeNode<'ref'> {
+    /** Name of the referenced Type */
+    ref: string;
+    /** Parameters to potentially fill in a generic when it is resolved. Position is preserved */
+    genericArguments?: Array<NodeType>;
+}
+declare type RefType = RefNode & Annotations;
+interface ObjectProperty {
+    /** If this property is required */
+    required: boolean;
+    /** The type of the property */
+    node: NodeType;
+}
+interface ObjectNode extends TypeNode<'object'> {
+    /** the properties associated with an object */
+    properties: {
+        [name: string]: ObjectProperty;
+    };
+    /** What type, if any, of additional properties are allowed on the object */
+    additionalProperties: false | NodeType;
+}
+declare type ObjectType = ObjectNode & CommonTypeInfo<object> & Annotations;
+interface ArrayNode extends TypeNode<'array'> {
+    /** What types are allowed in the array */
+    elementType: NodeType;
+}
+declare type ArrayType<T = unknown> = ArrayNode & CommonTypeInfo<Array<T>> & Annotations;
+interface ConditionalNode extends TypeNode<'conditional'> {
+    /** The check arguments */
+    check: {
+        /** operator */
+        left: NodeType;
+        /** operand */
+        right: NodeType;
+    };
+    /** The resulting values to use */
+    value: {
+        /** If the conditional is true */
+        true: NodeType;
+        /** If the conditional is false */
+        false: NodeType;
+    };
+}
+declare type ConditionalType = ConditionalNode & Annotations;
+interface TupleNode extends TypeNode<'tuple'> {
+    /** The types in the tuple */
+    elementTypes: Array<NodeType>;
+    /** The minimum number of items */
+    minItems: number;
+    /** What, if any, additional types can be provided */
+    additionalItems: false | NodeType;
+}
+declare type TupleType<T extends unknown[] = unknown[]> = TupleNode & CommonTypeInfo<T> & Annotations;
+declare type AndType = TypeNode<'and'> & Annotations & {
+    /** Nodes in intersection */
+    and: NodeType[];
+};
+declare type OrType = TypeNode<'or'> & Annotations & {
+    /** Nodes in the union */
+    or: NodeType[];
+};
+declare type TemplateLiteralType = TypeNode<'template'> & Annotations & {
+    /** String version of regex used to validate template */
+    format: string;
+};
+declare type RecordType = TypeNode<'record'> & Annotations & {
+    /** Key types for the Record */
+    keyType: NodeType;
+    /** Value types for the Record */
+    valueType: NodeType;
+};
+declare type FunctionTypeParameters = {
+    /** String name of the function parameter */
+    name: string;
+    /** The type constraint of the parameter */
+    type: NodeType;
+    /** Indicates that the parameter is optional */
+    optional?: true;
+    /** Default value for the parameter if nothing is supplied */
+    default?: NodeType;
+};
+declare type FunctionType = TypeNode<'function'> & Annotations & {
+    /** Types for the parameters, in order, for the function */
+    parameters: Array<FunctionTypeParameters>;
+    /** Return type of the function */
+    returnType?: NodeType;
+};
+/** Primitive Type Nodes */
+declare type PrimitiveTypes = NeverType | NullType | StringType | NumberType | BooleanType | AnyType | UnknownType | UndefinedType;
+/** Set of all Node Types */
+declare type NodeType = AnyType | UnknownType | UndefinedType | NullType | NeverType | StringType | TemplateLiteralType | NumberType | BooleanType | ObjectType | ArrayType | TupleType | RecordType | AndType | OrType | RefType | FunctionType | ConditionalType;
+declare type NamedType<T extends NodeType = NodeType> = T & {
+    /** Name of the exported interface/type */
+    name: string;
+    /** File the type was exported from */
+    source: string;
+};
+interface ParamTypeNode {
+    /** Symbol used to identify the generic in the interface/type */
+    symbol: string;
+    /** The type constraint for the generic */
+    constraints?: NodeType;
+    /** The default value for the generic if no value is provided */
+    default?: NodeType;
+}
+declare type NamedTypeWithGenerics<T extends NodeType = NodeType> = NamedType<T> & {
+    /** Generics for the Named Type that need to be filled in */
+    genericTokens: Array<ParamTypeNode>;
+};
+declare type NodeTypeWithGenerics<T extends NodeType = NodeType> = T & {
+    /** Generics for the Node that need to be filled in */
+    genericTokens: Array<ParamTypeNode>;
+};
+
+declare type TransformFunction = (input: NamedType<NodeType>, capabilityType: string) => void;
+interface Capability {
+    /** Name of the capability that is provided to Player */
+    name: string;
+    /** List of XLRs that are provided for the Capability */
+    provides: Array<string>;
+}
+interface Manifest {
+    /** Name of the plugin */
+    pluginName: string;
+    /** Map of capabilities provided by the plugin to the name of the XLR for the capabilities */
+    capabilities?: Map<string, Array<string>>;
+}
+interface TSManifest {
+    /** Name of the plugin */
+    pluginName: string;
+    /** Index of capabilities provided by the plugin to the name of the XLR for the capabilities */
+    capabilities: {
+        [capability: string]: Array<NamedType>;
+    };
+}
+
+export { AndType, Annotations, AnyType, ArrayNode, ArrayType, BooleanType, Capability, CommonTypeInfo, ConditionalNode, ConditionalType, Const, Enum, FunctionType, FunctionTypeParameters, Manifest, NamedType, NamedTypeWithGenerics, NeverType, NodeType, NodeTypeWithGenerics, NullType, NumberType, ObjectNode, ObjectProperty, ObjectType, OrType, ParamTypeNode, PrimitiveTypes, RecordType, RefNode, RefType, StringType, TSManifest, TemplateLiteralType, TransformFunction, TupleNode, TupleType, TypeMap, TypeNode, UndefinedType, UnknownType };

package/dist/index.esm.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@player-tools/xlr",
+  "version": "0.0.2-next.0",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {},
+  "dependencies": {
+    "@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/core.ts

@@ -0,0 +1,253 @@
+export interface Annotations {
+  /** The name used to reference this type */
+  name?: string;
+  /** The path within a type to this type (may be the same as `name` ) */
+  title?: string;
+  /** The JSDoc string for this type */
+  description?: string;
+  /** The JSDoc `@example` string for this type */
+  examples?: string | Array<string>;
+  /** The JSDoc `@default` string for this type */
+  default?: string;
+  /** The JSDoc `@see` string for this type */
+  see?: string | Array<string>;
+  /** The Typescript comment associated with the type */
+  comment?: string;
+}
+
+export interface TypeMap {
+  /** */
+  and: void;
+  /** */
+  or: void;
+  /** */
+  ref: string;
+  /** */
+  any: unknown;
+  /** */
+  null: null;
+  /** */
+  string: string;
+  /** */
+  number: number;
+  /** */
+  boolean: boolean;
+  /** */
+  object: object;
+  /** */
+  array: Array<unknown>;
+  /** */
+  tuple: Array<unknown>;
+  /** */
+  function: () => unknown;
+  /** */
+  record: Record<string | number | symbol, unknown>;
+  /** */
+  undefined: undefined;
+  /** */
+  never: never;
+  /**  */
+  unknown: unknown;
+}
+
+export interface Const<T> {
+  /** The literal value for the node */
+  const?: T;
+}
+export interface Enum<T> {
+  /** The list of enums for the node */
+  enum?: Array<T>;
+}
+export type CommonTypeInfo<T> = Const<T> & Enum<T>;
+
+export interface TypeNode<Name = string> {
+  /** The type of Node */
+  type: Name;
+}
+
+export type AnyType = TypeNode<'any'> & CommonTypeInfo<any> & Annotations;
+
+export type UnknownType = TypeNode<'unknown'> &
+  CommonTypeInfo<unknown> &
+  Annotations;
+export type UndefinedType = TypeNode<'undefined'> &
+  CommonTypeInfo<undefined> &
+  Annotations;
+export type NullType = TypeNode<'null'> & CommonTypeInfo<null> & Annotations;
+export type StringType = TypeNode<'string'> &
+  CommonTypeInfo<string> &
+  Annotations;
+export type NumberType = TypeNode<'number'> &
+  CommonTypeInfo<number> &
+  Annotations;
+export type BooleanType = TypeNode<'boolean'> &
+  CommonTypeInfo<boolean> &
+  Annotations;
+export type NeverType = TypeNode<'never'> & CommonTypeInfo<never> & Annotations;
+
+export interface RefNode extends TypeNode<'ref'> {
+  /** Name of the referenced Type */
+  ref: string;
+  /** Parameters to potentially fill in a generic when it is resolved. Position is preserved */
+  genericArguments?: Array<NodeType>;
+}
+export type RefType = RefNode & Annotations;
+
+export interface ObjectProperty {
+  /** If this property is required */
+  required: boolean;
+  /** The type of the property */
+  node: NodeType;
+}
+export interface ObjectNode extends TypeNode<'object'> {
+  /** the properties associated with an object */
+  properties: {
+    [name: string]: ObjectProperty;
+  };
+  /** What type, if any, of additional properties are allowed on the object */
+  additionalProperties: false | NodeType;
+}
+export type ObjectType = ObjectNode & CommonTypeInfo<object> & Annotations;
+
+export interface ArrayNode extends TypeNode<'array'> {
+  /** What types are allowed in the array */
+  elementType: NodeType;
+}
+export type ArrayType<T = unknown> = ArrayNode &
+  CommonTypeInfo<Array<T>> &
+  Annotations;
+
+export interface ConditionalNode extends TypeNode<'conditional'> {
+  /** The check arguments */
+  check: {
+    /** operator */
+    left: NodeType;
+    /** operand */
+    right: NodeType;
+  };
+  /** The resulting values to use */
+  value: {
+    /** If the conditional is true */
+    true: NodeType;
+    /** If the conditional is false */
+    false: NodeType;
+  };
+}
+
+export type ConditionalType = ConditionalNode & Annotations;
+
+export interface TupleNode extends TypeNode<'tuple'> {
+  /** The types in the tuple */
+  elementTypes: Array<NodeType>;
+  /** The minimum number of items */
+  minItems: number;
+  /** What, if any, additional types can be provided */
+  additionalItems: false | NodeType;
+}
+export type TupleType<T extends unknown[] = unknown[]> = TupleNode &
+  CommonTypeInfo<T> &
+  Annotations;
+
+export type AndType = TypeNode<'and'> &
+  Annotations & {
+    /** Nodes in intersection */
+    and: NodeType[];
+  };
+export type OrType = TypeNode<'or'> &
+  Annotations & {
+    /** Nodes in the union */
+    or: NodeType[];
+  };
+
+export type TemplateLiteralType = TypeNode<'template'> &
+  Annotations & {
+    /** String version of regex used to validate template */
+    format: string;
+  };
+
+export type RecordType = TypeNode<'record'> &
+  Annotations & {
+    /** Key types for the Record */
+    keyType: NodeType;
+    /** Value types for the Record */
+    valueType: NodeType;
+  };
+
+export type FunctionTypeParameters = {
+  /** String name of the function parameter */
+  name: string;
+  /** The type constraint of the parameter */
+  type: NodeType;
+  /** Indicates that the parameter is optional */
+  optional?: true;
+  /** Default value for the parameter if nothing is supplied */
+  default?: NodeType;
+};
+
+export type FunctionType = TypeNode<'function'> &
+  Annotations & {
+    /** Types for the parameters, in order, for the function */
+    parameters: Array<FunctionTypeParameters>;
+    /** Return type of the function */
+    returnType?: NodeType;
+  };
+
+/** Primitive Type Nodes */
+export type PrimitiveTypes =
+  | NeverType
+  | NullType
+  | StringType
+  | NumberType
+  | BooleanType
+  | AnyType
+  | UnknownType
+  | UndefinedType;
+
+/** Set of all Node Types */
+export type NodeType =
+  | AnyType
+  | UnknownType
+  | UndefinedType
+  | NullType
+  | NeverType
+  | StringType
+  | TemplateLiteralType
+  | NumberType
+  | BooleanType
+  | ObjectType
+  | ArrayType
+  | TupleType
+  | RecordType
+  | AndType
+  | OrType
+  | RefType
+  | FunctionType
+  | ConditionalType;
+
+export type NamedType<T extends NodeType = NodeType> = T & {
+  /** Name of the exported interface/type */
+  name: string;
+
+  /** File the type was exported from */
+  source: string;
+};
+
+export interface ParamTypeNode {
+  /** Symbol used to identify the generic in the interface/type */
+  symbol: string;
+  /** The type constraint for the generic */
+  constraints?: NodeType;
+  /** The default value for the generic if no value is provided */
+  default?: NodeType;
+}
+
+export type NamedTypeWithGenerics<T extends NodeType = NodeType> =
+  NamedType<T> & {
+    /** Generics for the Named Type that need to be filled in */
+    genericTokens: Array<ParamTypeNode>;
+  };
+
+export type NodeTypeWithGenerics<T extends NodeType = NodeType> = T & {
+  /** Generics for the Node that need to be filled in */
+  genericTokens: Array<ParamTypeNode>;
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './utility';

package/src/utility.ts

@@ -0,0 +1,30 @@
+import type { NamedType, NodeType } from '.';
+
+export type TransformFunction = (
+  input: NamedType<NodeType>,
+  capabilityType: string
+) => void;
+
+export interface Capability {
+  /** Name of the capability that is provided to Player */
+  name: string;
+  /** List of XLRs that are provided for the Capability */
+  provides: Array<string>;
+}
+
+export interface Manifest {
+  /** Name of the plugin */
+  pluginName: string;
+  /** Map of capabilities provided by the plugin to the name of the XLR for the capabilities */
+  capabilities?: Map<string, Array<string>>;
+}
+
+export interface TSManifest {
+  /** Name of the plugin */
+  pluginName: string;
+
+  /** Index of capabilities provided by the plugin to the name of the XLR for the capabilities */
+  capabilities: {
+    [capability: string]: Array<NamedType>;
+  };
+}