@xlr-lib/xlr 0.1.1-next.0

package/dist/cjs/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/types/javascript/src/index.ts
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/types/javascript/src/index.ts"],"sourcesContent":["export * from \"./core\";\nexport * from \"./utility\";\n"],"mappings":";;;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/index.legacy-esm.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "types"
+  ],
+  "name": "@xlr-lib/xlr",
+  "version": "0.1.1-next.0",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/index.legacy-esm.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    "./dist/index.css": "./dist/index.css",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/cjs/index.cjs"
+    }
+  },
+  "dependencies": {
+    "tslib": "^2.6.2"
+  },
+  "peerDependencies": {}
+}

package/src/core.ts

@@ -0,0 +1,242 @@
+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;
+  /** The JSDoc `@meta` string for this type */
+  meta?: Record<string, string>;
+}
+
+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 VoidType = TypeNode<"void"> & CommonTypeInfo<void> & 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>;
+  /** Optional property to access when the reference is resolved */
+  property?: string;
+}
+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;
+  };
+  /** A custom primitive that this object extends that is to be resolved when used */
+  extends?: RefType;
+  /** 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 TupleMember {
+  /** Optional Name of the Tuple Member */
+  name?: string;
+  /** Type constraint of the Tuple Member */
+  type: NodeType;
+  /** Is the Tuple Member Optional */
+  optional?: boolean;
+}
+
+export interface TupleNode extends TypeNode<"tuple"> {
+  /** The types in the tuple */
+  elementTypes: Array<TupleMember>;
+  /** 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
+  | VoidType;
+
+/** 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
+  | VoidType;
+
+export type NodeTypeStrings = Pick<NodeType, "type">["type"];
+
+export type NodeTypeMap = {
+  [K in NodeTypeStrings]: Extract<NodeType, { type: K }>;
+};
+
+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,32 @@
+import type { NamedType, NodeType } from ".";
+
+export type TransformFunction = (
+  input: NamedType<NodeType> | NodeType,
+  capabilityType: string,
+) => NamedType | NodeType;
+
+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>>;
+  /** CustomPrimitives that are the most basic types in the Payer Ecosystem */
+  customPrimitives?: 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>;
+  };
+}

package/types/core.d.ts

@@ -0,0 +1,172 @@
+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;
+    /** The JSDoc `@meta` string for this type */
+    meta?: Record<string, string>;
+}
+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 VoidType = TypeNode<"void"> & CommonTypeInfo<void> & 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>;
+    /** Optional property to access when the reference is resolved */
+    property?: string;
+}
+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;
+    };
+    /** A custom primitive that this object extends that is to be resolved when used */
+    extends?: RefType;
+    /** 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 TupleMember {
+    /** Optional Name of the Tuple Member */
+    name?: string;
+    /** Type constraint of the Tuple Member */
+    type: NodeType;
+    /** Is the Tuple Member Optional */
+    optional?: boolean;
+}
+export interface TupleNode extends TypeNode<"tuple"> {
+    /** The types in the tuple */
+    elementTypes: Array<TupleMember>;
+    /** 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 | VoidType;
+/** 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 | VoidType;
+export type NodeTypeStrings = Pick<NodeType, "type">["type"];
+export type NodeTypeMap = {
+    [K in NodeTypeStrings]: Extract<NodeType, {
+        type: K;
+    }>;
+};
+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>;
+};
+//# sourceMappingURL=core.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core";
+export * from "./utility";
+//# sourceMappingURL=index.d.ts.map

package/types/utility.d.ts

@@ -0,0 +1,25 @@
+import type { NamedType, NodeType } from ".";
+export type TransformFunction = (input: NamedType<NodeType> | NodeType, capabilityType: string) => NamedType | NodeType;
+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>>;
+    /** CustomPrimitives that are the most basic types in the Payer Ecosystem */
+    customPrimitives?: 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>;
+    };
+}
+//# sourceMappingURL=utility.d.ts.map