@player-tools/xlr-utils 0.4.1 → 0.4.2--canary.63.1238

package/dist/index.cjs.js

@@ -253,23 +253,39 @@ function makePropertyMap(node) {
 function isNode(obj) {
   return typeof obj !== "string" || typeof obj !== "number" || typeof obj !== "boolean";
 }
-function resolveConditional(conditional) {
-  const { left, right } = conditional.check;
-  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    let conditionalResult = conditional.value.false;
-    if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
-      conditionalResult = conditional.value.true;
-    } else if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
-      conditionalResult = conditional.value.true;
-    } else if (left.type === right.type) {
-      if (left.const && right.const) {
-        if (left.const === right.const) {
-          conditionalResult = conditional.value.true;
+function computeExtends(a, b) {
+  if ((a.type === "any" || a.type === "unknown") && (b.type === "any" || b.type === "unknown")) {
+    return true;
+  }
+  if ((a.type === "null" || a.type === "undefined") && (b.type === "null" || b.type === "undefined")) {
+    return true;
+  }
+  if (a.type === b.type) {
+    if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {
+      if (a.const && b.const) {
+        if (a.const === b.const) {
+          return true;
         }
       } else {
-        conditionalResult = conditional.value.true;
+        return true;
+      }
+    }
+    if (a.type === "object" && b.type === "object") {
+      for (const property in b.properties) {
+        const propertyNode = b.properties[property];
+        if (!a.properties[property] || !computeExtends(a.properties[property].node, propertyNode.node)) {
+          return false;
+        }
       }
+      return true;
     }
+  }
+  return false;
+}
+function resolveConditional(conditional) {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    const conditionalResult = conditional.value.false;
     if (isGenericNodeType(conditional)) {
       const genericMap = new Map();
       conditional.genericTokens.forEach((token) => {
@@ -324,10 +340,12 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
     newObject.properties[property] = operand.properties[property];
   }
   if (newObject.additionalProperties && operand.additionalProperties) {
-    newObject.additionalProperties = {
-      type: "and",
-      and: [newObject.additionalProperties, operand.additionalProperties]
-    };
+    if (!isPrimitiveTypeNode(newObject.additionalProperties) || !isPrimitiveTypeNode(operand.additionalProperties) || newObject.additionalProperties.type !== operand.additionalProperties.type) {
+      newObject.additionalProperties = {
+        type: "and",
+        and: [newObject.additionalProperties, operand.additionalProperties]
+      };
+    }
   } else if (operand.additionalProperties) {
     newObject.additionalProperties = operand.additionalProperties;
   }
@@ -545,6 +563,20 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
   }
   throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
 }
+function applyExcludeToNodeType(baseObject, filters) {
+  const remainingMembers = baseObject.or.filter((type) => {
+    if (filters.type === "or") {
+      return !filters.or.some((filter) => !computeExtends(type, filter));
+    }
+    return !computeExtends(type, filters);
+  });
+  if (remainingMembers.length === 1) {
+    return remainingMembers[0];
+  }
+  return __spreadProps(__spreadValues({}, baseObject), {
+    or: remainingMembers
+  });
+}
 
 function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
   const fsMap = tsvfs__namespace.createDefaultMapFromNodeModules({}, ts__namespace);
@@ -751,10 +783,12 @@ function createDocString(node) {
   return symbolDisplayToString(createTSDocString(node));
 }
 
+exports.applyExcludeToNodeType = applyExcludeToNodeType;
 exports.applyPartialOrRequiredToNodeType = applyPartialOrRequiredToNodeType;
 exports.applyPickOrOmitToNodeType = applyPickOrOmitToNodeType;
 exports.buildTemplateRegex = buildTemplateRegex;
 exports.computeEffectiveObject = computeEffectiveObject;
+exports.computeExtends = computeExtends;
 exports.createDocString = createDocString;
 exports.createTSDocString = createTSDocString;
 exports.decorateNode = decorateNode;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import ts__default, { SymbolDisplayPart } from 'typescript';
-import { Annotations, NodeType, NodeTypeWithGenerics, NamedType, NamedTypeWithGenerics, PrimitiveTypes, ConditionalType, RefNode, ObjectType } from '@player-tools/xlr';
+import { Annotations, NodeType, OrType, NodeTypeWithGenerics, NamedType, NamedTypeWithGenerics, PrimitiveTypes, ConditionalType, RefNode, ObjectType } from '@player-tools/xlr';
 import { Node } from 'jsonc-parser';
 
 /**
@@ -44,6 +44,8 @@ declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeTy
 declare function applyPickOrOmitToNodeType(baseObject: NodeType, operation: 'Pick' | 'Omit', properties: Set<string>): NodeType | undefined;
 /** Applies the TS `Omit` type to an interface/union/intersection */
 declare function applyPartialOrRequiredToNodeType(baseObject: NodeType, modifier: boolean): NodeType;
+/** Applies the TS `Exclude` type to a union */
+declare function applyExcludeToNodeType(baseObject: OrType, filters: NodeType | OrType): NodeType;
 
 /**
  * Returns if the Object Property is optional
@@ -106,6 +108,10 @@ declare function makePropertyMap(node: Node): Map<string, Node>;
  * Checks if property is a leaf node or another node
  */
 declare function isNode(obj: Node | string | number | boolean): obj is Node;
+/**
+ * Computes if the first arg extends the second arg
+ */
+declare function computeExtends(a: NodeType, b: NodeType): boolean;
 /**
  * Attempts to resolve a conditional type
  */
@@ -153,4 +159,4 @@ declare function symbolDisplayToString(displayParts: Array<SymbolDisplayPart>):
 /** Create a documentation string from node */
 declare function createDocString(node: NodeType): string;
 
-export { PropertyNode, SetupReturnType, TopLevelDeclaration, TopLevelNode, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, createDocString, createTSDocString, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelDeclaration, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, symbolDisplayToString, tsStripOptionalType };
+export { PropertyNode, SetupReturnType, TopLevelDeclaration, TopLevelNode, applyExcludeToNodeType, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, computeExtends, createDocString, createTSDocString, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelDeclaration, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, symbolDisplayToString, tsStripOptionalType };

package/dist/index.esm.js

@@ -226,23 +226,39 @@ function makePropertyMap(node) {
 function isNode(obj) {
   return typeof obj !== "string" || typeof obj !== "number" || typeof obj !== "boolean";
 }
-function resolveConditional(conditional) {
-  const { left, right } = conditional.check;
-  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    let conditionalResult = conditional.value.false;
-    if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
-      conditionalResult = conditional.value.true;
-    } else if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
-      conditionalResult = conditional.value.true;
-    } else if (left.type === right.type) {
-      if (left.const && right.const) {
-        if (left.const === right.const) {
-          conditionalResult = conditional.value.true;
+function computeExtends(a, b) {
+  if ((a.type === "any" || a.type === "unknown") && (b.type === "any" || b.type === "unknown")) {
+    return true;
+  }
+  if ((a.type === "null" || a.type === "undefined") && (b.type === "null" || b.type === "undefined")) {
+    return true;
+  }
+  if (a.type === b.type) {
+    if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {
+      if (a.const && b.const) {
+        if (a.const === b.const) {
+          return true;
         }
       } else {
-        conditionalResult = conditional.value.true;
+        return true;
+      }
+    }
+    if (a.type === "object" && b.type === "object") {
+      for (const property in b.properties) {
+        const propertyNode = b.properties[property];
+        if (!a.properties[property] || !computeExtends(a.properties[property].node, propertyNode.node)) {
+          return false;
+        }
       }
+      return true;
     }
+  }
+  return false;
+}
+function resolveConditional(conditional) {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    const conditionalResult = conditional.value.false;
     if (isGenericNodeType(conditional)) {
       const genericMap = new Map();
       conditional.genericTokens.forEach((token) => {
@@ -297,10 +313,12 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
     newObject.properties[property] = operand.properties[property];
   }
   if (newObject.additionalProperties && operand.additionalProperties) {
-    newObject.additionalProperties = {
-      type: "and",
-      and: [newObject.additionalProperties, operand.additionalProperties]
-    };
+    if (!isPrimitiveTypeNode(newObject.additionalProperties) || !isPrimitiveTypeNode(operand.additionalProperties) || newObject.additionalProperties.type !== operand.additionalProperties.type) {
+      newObject.additionalProperties = {
+        type: "and",
+        and: [newObject.additionalProperties, operand.additionalProperties]
+      };
+    }
   } else if (operand.additionalProperties) {
     newObject.additionalProperties = operand.additionalProperties;
   }
@@ -518,6 +536,20 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
   }
   throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
 }
+function applyExcludeToNodeType(baseObject, filters) {
+  const remainingMembers = baseObject.or.filter((type) => {
+    if (filters.type === "or") {
+      return !filters.or.some((filter) => !computeExtends(type, filter));
+    }
+    return !computeExtends(type, filters);
+  });
+  if (remainingMembers.length === 1) {
+    return remainingMembers[0];
+  }
+  return __spreadProps(__spreadValues({}, baseObject), {
+    or: remainingMembers
+  });
+}
 
 function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
   const fsMap = tsvfs.createDefaultMapFromNodeModules({}, ts);
@@ -724,5 +756,5 @@ function createDocString(node) {
   return symbolDisplayToString(createTSDocString(node));
 }
 
-export { applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, createDocString, createTSDocString, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelDeclaration, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, symbolDisplayToString, tsStripOptionalType };
+export { applyExcludeToNodeType, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, computeExtends, createDocString, createTSDocString, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelDeclaration, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, symbolDisplayToString, tsStripOptionalType };
 //# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@player-tools/xlr-utils",
-  "version": "0.4.1",
+  "version": "0.4.2--canary.63.1238",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -10,7 +10,7 @@
     "jsonc-parser": "^2.3.1"
   },
   "dependencies": {
-    "@player-tools/xlr": "0.4.1",
+    "@player-tools/xlr": "0.4.2--canary.63.1238",
     "@typescript/vfs": "^1.4.0",
     "@babel/runtime": "7.15.4"
   },

package/src/ts-helpers.ts

@@ -5,8 +5,9 @@ import type {
   NodeType,
   ObjectProperty,
   ObjectType,
+  OrType,
 } from '@player-tools/xlr';
-import { resolveConditional } from './validation-helpers';
+import { computeExtends, resolveConditional } from './validation-helpers';
 import { isGenericNodeType } from './type-checks';
 
 /**
@@ -359,3 +360,26 @@ export function applyPartialOrRequiredToNodeType(
     }`
   );
 }
+
+/** Applies the TS `Exclude` type to a union */
+export function applyExcludeToNodeType(
+  baseObject: OrType,
+  filters: NodeType | OrType
+): NodeType {
+  const remainingMembers = baseObject.or.filter((type) => {
+    if (filters.type === 'or') {
+      return !filters.or.some((filter) => !computeExtends(type, filter));
+    }
+
+    return !computeExtends(type, filters);
+  });
+
+  if (remainingMembers.length === 1) {
+    return remainingMembers[0];
+  }
+
+  return {
+    ...baseObject,
+    or: remainingMembers,
+  };
+}

package/src/validation-helpers.ts

@@ -1,3 +1,5 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
 import type { Node } from 'jsonc-parser';
 import type {
   ConditionalType,
@@ -55,34 +57,61 @@ export function isNode(obj: Node | string | number | boolean): obj is Node {
 }
 
 /**
- * Attempts to resolve a conditional type
+ * Computes if the first arg extends the second arg
  */
-export function resolveConditional(conditional: ConditionalType): NodeType {
-  const { left, right } = conditional.check;
-  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    let conditionalResult = conditional.value.false;
+export function computeExtends(a: NodeType, b: NodeType): boolean {
+  // special case for any/unknown being functionally the same
+  if (
+    (a.type === 'any' || a.type === 'unknown') &&
+    (b.type === 'any' || b.type === 'unknown')
+  ) {
+    return true;
+  }
 
-    if (
-      (left.type === 'any' || left.type === 'unknown') &&
-      (right.type === 'any' || right.type === 'unknown')
-    ) {
-      // special case for any/unknown being functionally the same
-      conditionalResult = conditional.value.true;
-    } else if (
-      (left.type === 'null' || left.type === 'undefined') &&
-      (right.type === 'null' || right.type === 'undefined')
-    ) {
-      // special case for null/undefined being functionally the same
-      conditionalResult = conditional.value.true;
-    } else if (left.type === right.type) {
-      if (left.const && right.const) {
-        if (left.const === right.const) {
-          conditionalResult = conditional.value.true;
+  // special case for null/undefined being functionally the same
+  if (
+    (a.type === 'null' || a.type === 'undefined') &&
+    (b.type === 'null' || b.type === 'undefined')
+  ) {
+    return true;
+  }
+
+  if (a.type === b.type) {
+    if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {
+      if (a.const && b.const) {
+        if (a.const === b.const) {
+          return true;
         }
       } else {
-        conditionalResult = conditional.value.true;
+        return true;
+      }
+    }
+
+    if (a.type === 'object' && b.type === 'object') {
+      for (const property in b.properties) {
+        const propertyNode = b.properties[property];
+        if (
+          !a.properties[property] ||
+          !computeExtends(a.properties[property].node, propertyNode.node)
+        ) {
+          return false;
+        }
       }
+
+      return true;
     }
+  }
+
+  return false;
+}
+
+/**
+ * Attempts to resolve a conditional type
+ */
+export function resolveConditional(conditional: ConditionalType): NodeType {
+  const { left, right } = conditional.check;
+  if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
+    const conditionalResult = conditional.value.false;
 
     // Compose first level generics here since `conditionalResult` won't have them
     if (isGenericNodeType(conditional)) {
@@ -190,10 +219,16 @@ export function computeEffectiveObject(
   }
 
   if (newObject.additionalProperties && operand.additionalProperties) {
-    newObject.additionalProperties = {
-      type: 'and',
-      and: [newObject.additionalProperties, operand.additionalProperties],
-    };
+    if (
+      !isPrimitiveTypeNode(newObject.additionalProperties) ||
+      !isPrimitiveTypeNode(operand.additionalProperties) ||
+      newObject.additionalProperties.type !== operand.additionalProperties.type
+    ) {
+      newObject.additionalProperties = {
+        type: 'and',
+        and: [newObject.additionalProperties, operand.additionalProperties],
+      };
+    }
   } else if (operand.additionalProperties) {
     newObject.additionalProperties = operand.additionalProperties;
   }