@player-tools/xlr-utils 0.4.2-next.0 → 0.4.2-next.1

package/dist/index.cjs.js

@@ -270,6 +270,9 @@ function computeExtends(a, b) {
         return true;
       }
     }
+    if (a.type === "ref" && b.type === "ref") {
+      return a.ref === b.ref;
+    }
     if (a.type === "object" && b.type === "object") {
       for (const property in b.properties) {
         const propertyNode = b.properties[property];
@@ -280,6 +283,15 @@ function computeExtends(a, b) {
       return true;
     }
   }
+  if (isPrimitiveTypeNode(a) && b.type === "or") {
+    return b.or.every((member) => computeExtends(a, member));
+  }
+  if (isPrimitiveTypeNode(b) && a.type === "or") {
+    return a.or.every((member) => computeExtends(b, member));
+  }
+  if (a.type === "or" && b.type === "or") {
+    return a.or.every((x) => b.or.some((y) => computeExtends(x, y)));
+  }
   return false;
 }
 function resolveConditional(conditional) {
@@ -325,7 +337,7 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
   var _a, _b, _c, _d;
   const baseObjectName = (_b = (_a = base.name) != null ? _a : base.title) != null ? _b : "object literal";
   const operandObjectName = (_d = (_c = operand.name) != null ? _c : operand.title) != null ? _d : "object literal";
-  const newObject = __spreadProps$1(__spreadValues$1({}, base), {
+  const newObject = __spreadProps$1(__spreadValues$1({}, JSON.parse(JSON.stringify(base))), {
     name: `${baseObjectName} & ${operandObjectName}`,
     description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
     genericTokens: [
@@ -334,8 +346,10 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
     ]
   });
   for (const property in operand.properties) {
-    if (newObject.properties[property] !== void 0 && newObject.properties[property].node.type !== operand.properties[property].node.type && errorOnOverlap) {
-      throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+    if (newObject.properties[property] !== void 0 && errorOnOverlap) {
+      if (!computeExtends(newObject.properties[property].node, operand.properties[property].node)) {
+        throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+      }
     }
     newObject.properties[property] = operand.properties[property];
   }
@@ -566,7 +580,7 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
 function applyExcludeToNodeType(baseObject, filters) {
   const remainingMembers = baseObject.or.filter((type) => {
     if (filters.type === "or") {
-      return !filters.or.some((filter) => !computeExtends(type, filter));
+      return !filters.or.some((filter) => computeExtends(type, filter));
     }
     return !computeExtends(type, filters);
   });

package/dist/index.esm.js

@@ -243,6 +243,9 @@ function computeExtends(a, b) {
         return true;
       }
     }
+    if (a.type === "ref" && b.type === "ref") {
+      return a.ref === b.ref;
+    }
     if (a.type === "object" && b.type === "object") {
       for (const property in b.properties) {
         const propertyNode = b.properties[property];
@@ -253,6 +256,15 @@ function computeExtends(a, b) {
       return true;
     }
   }
+  if (isPrimitiveTypeNode(a) && b.type === "or") {
+    return b.or.every((member) => computeExtends(a, member));
+  }
+  if (isPrimitiveTypeNode(b) && a.type === "or") {
+    return a.or.every((member) => computeExtends(b, member));
+  }
+  if (a.type === "or" && b.type === "or") {
+    return a.or.every((x) => b.or.some((y) => computeExtends(x, y)));
+  }
   return false;
 }
 function resolveConditional(conditional) {
@@ -298,7 +310,7 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
   var _a, _b, _c, _d;
   const baseObjectName = (_b = (_a = base.name) != null ? _a : base.title) != null ? _b : "object literal";
   const operandObjectName = (_d = (_c = operand.name) != null ? _c : operand.title) != null ? _d : "object literal";
-  const newObject = __spreadProps$1(__spreadValues$1({}, base), {
+  const newObject = __spreadProps$1(__spreadValues$1({}, JSON.parse(JSON.stringify(base))), {
     name: `${baseObjectName} & ${operandObjectName}`,
     description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
     genericTokens: [
@@ -307,8 +319,10 @@ function computeEffectiveObject(base, operand, errorOnOverlap = true) {
     ]
   });
   for (const property in operand.properties) {
-    if (newObject.properties[property] !== void 0 && newObject.properties[property].node.type !== operand.properties[property].node.type && errorOnOverlap) {
-      throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+    if (newObject.properties[property] !== void 0 && errorOnOverlap) {
+      if (!computeExtends(newObject.properties[property].node, operand.properties[property].node)) {
+        throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+      }
     }
     newObject.properties[property] = operand.properties[property];
   }
@@ -539,7 +553,7 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
 function applyExcludeToNodeType(baseObject, filters) {
   const remainingMembers = baseObject.or.filter((type) => {
     if (filters.type === "or") {
-      return !filters.or.some((filter) => !computeExtends(type, filter));
+      return !filters.or.some((filter) => computeExtends(type, filter));
     }
     return !computeExtends(type, filters);
   });

package/package.json

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

package/src/ts-helpers.ts

@@ -368,7 +368,7 @@ export function applyExcludeToNodeType(
 ): NodeType {
   const remainingMembers = baseObject.or.filter((type) => {
     if (filters.type === 'or') {
-      return !filters.or.some((filter) => !computeExtends(type, filter));
+      return !filters.or.some((filter) => computeExtends(type, filter));
     }
 
     return !computeExtends(type, filters);

package/src/validation-helpers.ts

@@ -76,6 +76,7 @@ export function computeExtends(a: NodeType, b: NodeType): boolean {
     return true;
   }
 
+  // check simple case of equal types
   if (a.type === b.type) {
     if (isPrimitiveTypeNode(a) && isPrimitiveTypeNode(b)) {
       if (a.const && b.const) {
@@ -87,6 +88,10 @@ export function computeExtends(a: NodeType, b: NodeType): boolean {
       }
     }
 
+    if (a.type === 'ref' && b.type === 'ref') {
+      return a.ref === b.ref;
+    }
+
     if (a.type === 'object' && b.type === 'object') {
       for (const property in b.properties) {
         const propertyNode = b.properties[property];
@@ -102,6 +107,18 @@ export function computeExtends(a: NodeType, b: NodeType): boolean {
     }
   }
 
+  if (isPrimitiveTypeNode(a) && b.type === 'or') {
+    return b.or.every((member) => computeExtends(a, member));
+  }
+
+  if (isPrimitiveTypeNode(b) && a.type === 'or') {
+    return a.or.every((member) => computeExtends(b, member));
+  }
+
+  if (a.type === 'or' && b.type === 'or') {
+    return a.or.every((x) => b.or.some((y) => computeExtends(x, y)));
+  }
+
   return false;
 }
 
@@ -193,7 +210,7 @@ export function computeEffectiveObject(
   const baseObjectName = base.name ?? base.title ?? 'object literal';
   const operandObjectName = operand.name ?? operand.title ?? 'object literal';
   const newObject = {
-    ...base,
+    ...JSON.parse(JSON.stringify(base)),
     name: `${baseObjectName} & ${operandObjectName}`,
     description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
     genericTokens: [
@@ -201,18 +218,20 @@ export function computeEffectiveObject(
       ...(isGenericNodeType(operand) ? operand.genericTokens : []),
     ],
   };
+  // TODO this check needs to account for primitive -> primitive generic overlap
 
-  // eslint-disable-next-line no-restricted-syntax, guard-for-in
   for (const property in operand.properties) {
-    if (
-      newObject.properties[property] !== undefined &&
-      newObject.properties[property].node.type !==
-        operand.properties[property].node.type &&
-      errorOnOverlap
-    ) {
-      throw new Error(
-        `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`
-      );
+    if (newObject.properties[property] !== undefined && errorOnOverlap) {
+      if (
+        !computeExtends(
+          newObject.properties[property].node,
+          operand.properties[property].node
+        )
+      ) {
+        throw new Error(
+          `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`
+        );
+      }
     }
 
     newObject.properties[property] = operand.properties[property];