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

package/src/type-checks.ts

@@ -0,0 +1,106 @@
+import ts from 'typescript';
+import type {
+  NamedType,
+  NamedTypeWithGenerics,
+  NodeType,
+  NodeTypeWithGenerics,
+  PrimitiveTypes,
+} from '@player-tools/xlr';
+
+/**
+ * Returns if the Object Property is optional
+ */
+export function isOptionalProperty(node: ts.PropertySignature): boolean {
+  return node.questionToken?.kind === ts.SyntaxKind.QuestionToken;
+}
+
+/**
+ * Returns if the node is an Interface or Type with Generics
+ */
+export function isGenericInterfaceDeclaration(
+  node: ts.InterfaceDeclaration
+): boolean {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+
+/**
+ * Returns if the node is an Type Declaration with Generics
+ */
+export function isGenericTypeDeclaration(
+  node: ts.TypeAliasDeclaration
+): boolean {
+  const length = node.typeParameters?.length;
+  return length ? length > 0 : false;
+}
+
+/**
+ * Returns if the referenced type is a generic
+ */
+export function isTypeReferenceGeneric(
+  node: ts.TypeReferenceNode,
+  typeChecker: ts.TypeChecker
+): boolean {
+  const symbol = typeChecker.getSymbolAtLocation(node.typeName);
+  if (symbol && symbol.declarations) {
+    return symbol.declarations[0].kind === ts.SyntaxKind.TypeParameter;
+  }
+
+  return false;
+}
+
+export type TopLevelDeclaration =
+  | ts.InterfaceDeclaration
+  | ts.TypeAliasDeclaration;
+
+/**
+ * Returns if the node is an interface or a type declaration
+ */
+export function isTopLevelNode(node: ts.Node): node is TopLevelDeclaration {
+  return (
+    node.kind === ts.SyntaxKind.InterfaceDeclaration ||
+    node.kind === ts.SyntaxKind.TypeAliasDeclaration
+  );
+}
+
+/**
+ * Returns if the NodeType has generic tokens
+ */
+export function isGenericNodeType<T extends NodeType = NodeType>(
+  nt: NodeType
+): nt is NodeTypeWithGenerics<T> {
+  return (nt as NodeTypeWithGenerics).genericTokens?.length > 0;
+}
+
+/**
+ * Returns if the named type has generic tokens
+ */
+export function isGenericNamedType<T extends NamedType = NamedType>(
+  nt: NodeType
+): nt is NamedTypeWithGenerics<T> {
+  return (nt as NamedTypeWithGenerics).genericTokens?.length > 0;
+}
+
+/**
+ * Returns if the node is a `PrimitiveTypes`
+ */
+export function isPrimitiveTypeNode(node: NodeType): node is PrimitiveTypes {
+  return (
+    node.type === 'string' ||
+    node.type === 'number' ||
+    node.type === 'boolean' ||
+    node.type === 'null' ||
+    node.type === 'template' ||
+    node.type === 'any' ||
+    node.type === 'never' ||
+    node.type === 'undefined' ||
+    node.type === 'unknown'
+  );
+}
+
+/**
+ * Type Guard for non-null values
+ */
+export function isNonNullable<T>(a: T | null | undefined): a is NonNullable<T> {
+  return a !== null || a !== undefined;
+}

package/src/validation-helpers.ts

@@ -0,0 +1,88 @@
+import type { Node } from 'jsonc-parser';
+import type { ConditionalType, NodeType } from '@player-tools/xlr';
+import { isPrimitiveTypeNode } from './type-checks';
+
+export interface PropertyNode {
+  /** Equivalent Property Name */
+  key: string;
+
+  /** Equivalent Property Value */
+  value: Node;
+}
+
+/**
+ * Takes a property node and returns the underlying Key/Value Pairs
+ */
+export function propertyToTuple(node: Node): PropertyNode {
+  let key = node.children?.[0].value as string;
+  if (key.includes('-')) {
+    key = `'${key}'`;
+  }
+
+  return {
+    key,
+    value: node.children?.[1] as Node,
+  };
+}
+
+/**
+ * Turns a node's children into a map for easy access
+ */
+export function makePropertyMap(node: Node): Map<string, Node> {
+  const m = new Map();
+  node.children?.forEach((child) => {
+    const property = propertyToTuple(child);
+    m.set(property.key, property.value);
+  });
+  return m;
+}
+
+/**
+ * Checks if property is a leaf node or another node
+ */
+export function isNode(obj: Node | string | number | boolean): obj is Node {
+  return (
+    typeof obj !== 'string' ||
+    typeof obj !== 'number' ||
+    typeof obj !== 'boolean'
+  );
+}
+
+/**
+ * Attempts to resolve a conditional type
+ */
+export function resolveConditional(conditional: ConditionalType): NodeType {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    if (left.const && right.const) {
+      return left.const === right.const
+        ? conditional.value.true
+        : conditional.value.false;
+    }
+
+    // special case for any/unknown being functionally the same
+    if (
+      (left.type === 'any' || left.type === 'unknown') &&
+      (right.type === 'any' || right.type === 'unknown')
+    ) {
+      return conditional.value.true;
+    }
+
+    // special case for null/undefined being functionally the same
+    if (
+      (left.type === 'null' || left.type === 'undefined') &&
+      (right.type === 'null' || right.type === 'undefined')
+    ) {
+      return conditional.value.true;
+    }
+
+    if (left.type === right.type) {
+      return conditional.value.true;
+    }
+
+    return conditional.value.false;
+  }
+
+  // unable to process return original
+  return conditional;
+}