@xyo-network/crypto-nft-diviner-score-plugin 2.99.5 → 2.99.6

package/dist/neutral/index.cjs

@@ -3,7 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -38,43 +37,36 @@ var import_payload_builder = require("@xyo-network/payload-builder");
 // src/lib/rating/criteria/scoring/contract.ts
 var import_crypto_nft_score_model = require("@xyo-network/crypto-nft-score-model");
 var import_ethers = require("ethers");
-var scoreContractAddress = /* @__PURE__ */ __name((nft) => {
+var scoreContractAddress = (nft) => {
   if (!nft.address) return import_crypto_nft_score_model.FAIL;
   if (typeof nft.address !== "string") return import_crypto_nft_score_model.FAIL;
   if (!(0, import_ethers.isAddress)(nft.address)) return import_crypto_nft_score_model.FAIL;
   return import_crypto_nft_score_model.PASS;
-}, "scoreContractAddress");
+};
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
 var import_crypto_nft_score_model2 = require("@xyo-network/crypto-nft-score-model");
 
 // src/lib/rating/criteria/scoring/metadata/lib/urlHelpers.ts
-var import_url = require("@xylabs/url");
-var web3Protocols = [
-  "ipfs:",
-  "ar:"
-];
-var toUrl = /* @__PURE__ */ __name((url) => {
+var web3Protocols = ["ipfs:", "ar:"];
+var toUrl = (url) => {
   if (!url) return void 0;
   try {
-    return new import_url.URL(url);
+    return new URL(url);
   } catch {
     return void 0;
   }
-}, "toUrl");
-var isValidUrl = /* @__PURE__ */ __name((url) => toUrl(url) !== void 0, "isValidUrl");
-var isWeb3 = /* @__PURE__ */ __name((url) => web3Protocols.some((protocol) => protocol === toUrl(url)?.protocol), "isWeb3");
-var isSecure = /* @__PURE__ */ __name((url) => isWeb3(url) || toUrl(url)?.protocol === "https:", "isSecure");
+};
+var isValidUrl = (url) => toUrl(url) !== void 0;
+var isWeb3 = (url) => web3Protocols.some((protocol) => protocol === toUrl(url)?.protocol);
+var isSecure = (url) => isWeb3(url) || toUrl(url)?.protocol === "https:";
 
 // src/lib/rating/criteria/scoring/metadata/animationUrl.ts
-var scoreNftAnimationUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftAnimationUrl = (nft) => {
   return scoreAnimationUrl(nft.metadata?.animation_url);
-}, "scoreNftAnimationUrl");
-var scoreAnimationUrl = /* @__PURE__ */ __name((animation_url) => {
-  const score = [
-    0,
-    0
-  ];
+};
+var scoreAnimationUrl = (animation_url) => {
+  const score = [0, 0];
   if (animation_url === void 0 || animation_url === null) return import_crypto_nft_score_model2.PASS;
   (0, import_crypto_nft_score_model2.incrementPossible)(score);
   if (typeof animation_url !== "string") return score;
@@ -85,11 +77,11 @@ var scoreAnimationUrl = /* @__PURE__ */ __name((animation_url) => {
   (0, import_crypto_nft_score_model2.incrementTotalAndPossible)(score);
   if (!isWeb3(animation_url)) return score;
   return (0, import_crypto_nft_score_model2.incrementTotal)(score);
-}, "scoreAnimationUrl");
+};
 
 // src/lib/rating/criteria/scoring/metadata/attributes/evaluateAttributes.ts
 var import_crypto_nft_score_model3 = require("@xyo-network/crypto-nft-score-model");
-var isDate = /* @__PURE__ */ __name((value) => {
+var isDate = (value) => {
   if (isNumber(value)) {
     try {
       new Date(value);
@@ -99,38 +91,23 @@ var isDate = /* @__PURE__ */ __name((value) => {
     }
   }
   return false;
-}, "isDate");
-var isNumber = /* @__PURE__ */ __name((value) => typeof value === "number", "isNumber");
-var isPercentage = /* @__PURE__ */ __name((value) => isNumber(value) && value >= 0 && value <= 100, "isPercentage");
-var isNonEmptyString = /* @__PURE__ */ __name((value) => typeof value === "string" && value.length > 0, "isNonEmptyString");
-var isNonEmptyStringOrNumber = /* @__PURE__ */ __name((value) => value === "number" || isNonEmptyString(value), "isNonEmptyStringOrNumber");
-var evaluateNftAttributes = /* @__PURE__ */ __name((nft) => nft?.metadata?.attributes ? evaluateAttributes(nft?.metadata?.attributes) : [
-  0,
-  1
-], "evaluateNftAttributes");
-var evaluateAttributes = /* @__PURE__ */ __name((attributes) => {
-  if (!attributes || !Array.isArray(attributes) || attributes.length === 0) return [
-    0,
-    1
-  ];
-  const score = [
-    0,
-    0
-  ];
+};
+var isNumber = (value) => typeof value === "number";
+var isPercentage = (value) => isNumber(value) && value >= 0 && value <= 100;
+var isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+var isNonEmptyStringOrNumber = (value) => value === "number" || isNonEmptyString(value);
+var evaluateNftAttributes = (nft) => nft?.metadata?.attributes ? evaluateAttributes(nft?.metadata?.attributes) : [0, 1];
+var evaluateAttributes = (attributes) => {
+  if (!attributes || !Array.isArray(attributes) || attributes.length === 0) return [0, 1];
+  const score = [0, 0];
   for (const attribute of attributes) {
     const [attributeTotal, attributePossible] = evaluateAttribute(attribute);
     (0, import_crypto_nft_score_model3.incrementTotalAndPossible)(score, attributeTotal, attributePossible);
   }
-  return [
-    1,
-    1
-  ];
-}, "evaluateAttributes");
-var evaluateAttribute = /* @__PURE__ */ __name((attribute) => {
-  const score = [
-    0,
-    1
-  ];
+  return [1, 1];
+};
+var evaluateAttribute = (attribute) => {
+  const score = [0, 1];
   const max_value = attribute?.max_value;
   const trait_type = attribute?.trait_type;
   const value = attribute?.value;
@@ -143,8 +120,8 @@ var evaluateAttribute = /* @__PURE__ */ __name((attribute) => {
     if (isNumber(max_value) && isNumber(value) && value <= max_value) (0, import_crypto_nft_score_model3.incrementTotal)(score);
   }
   return score;
-}, "evaluateAttribute");
-var validDisplayType = /* @__PURE__ */ __name((attribute) => {
+};
+var validDisplayType = (attribute) => {
   switch (attribute?.display_type) {
     case "number":
     case "boost_number": {
@@ -169,75 +146,60 @@ var validDisplayType = /* @__PURE__ */ __name((attribute) => {
     }
   }
   return false;
-}, "validDisplayType");
+};
 
 // src/lib/rating/criteria/scoring/metadata/backgroundColor.ts
 var import_crypto_nft_score_model4 = require("@xyo-network/crypto-nft-score-model");
 var isHexColor = /^[\da-f]{6}$/i;
-var scoreNftBackgroundColor = /* @__PURE__ */ __name((nft) => {
+var scoreNftBackgroundColor = (nft) => {
   return scoreBackgroundColor(nft.metadata?.background_color);
-}, "scoreNftBackgroundColor");
-var scoreBackgroundColor = /* @__PURE__ */ __name((background_color) => {
-  const score = [
-    0,
-    0
-  ];
+};
+var scoreBackgroundColor = (background_color) => {
+  const score = [0, 0];
   if (background_color === void 0 || background_color === null) return import_crypto_nft_score_model4.PASS;
   (0, import_crypto_nft_score_model4.incrementPossible)(score);
   if (typeof background_color !== "string") return score;
   (0, import_crypto_nft_score_model4.incrementTotalAndPossible)(score);
   if (!isHexColor.test(background_color.toUpperCase())) return score;
   return (0, import_crypto_nft_score_model4.incrementTotal)(score);
-}, "scoreBackgroundColor");
+};
 
 // src/lib/rating/criteria/scoring/metadata/description.ts
 var import_crypto_nft_score_model5 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftDescription = /* @__PURE__ */ __name((nft) => {
+var scoreNftDescription = (nft) => {
   return scoreDescription(nft.metadata?.description);
-}, "scoreNftDescription");
-var scoreDescription = /* @__PURE__ */ __name((description) => {
-  const score = [
-    0,
-    1
-  ];
+};
+var scoreDescription = (description) => {
+  const score = [0, 1];
   if (!description || typeof description !== "string") return score;
   return (0, import_crypto_nft_score_model5.incrementTotal)(score);
-}, "scoreDescription");
+};
 
 // src/lib/rating/criteria/scoring/metadata/externalUrl.ts
 var import_crypto_nft_score_model6 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftExternalUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftExternalUrl = (nft) => {
   return scoreExternalUrl(nft?.metadata?.external_url);
-}, "scoreNftExternalUrl");
-var scoreExternalUrl = /* @__PURE__ */ __name((external_url) => {
-  const score = [
-    0,
-    2
-  ];
+};
+var scoreExternalUrl = (external_url) => {
+  const score = [0, 2];
   if (external_url === void 0 || external_url === null || typeof external_url !== "string" || !isValidUrl(external_url)) return score;
   (0, import_crypto_nft_score_model6.incrementTotal)(score);
   if (!isSecure(external_url)) return score;
   return (0, import_crypto_nft_score_model6.incrementTotal)(score);
-}, "scoreExternalUrl");
+};
 
 // src/lib/rating/criteria/scoring/metadata/image.ts
 var import_crypto_nft_score_model7 = require("@xyo-network/crypto-nft-score-model");
 var MaxPossibleImageScore = 3;
-var scoreNftImage = /* @__PURE__ */ __name((nft) => {
+var scoreNftImage = (nft) => {
   if (nft?.metadata?.image) {
     return scoreImage(nft.metadata?.image);
   } else {
-    return nft.metadata?.image_data ? import_crypto_nft_score_model7.PASS : [
-      0,
-      MaxPossibleImageScore
-    ];
+    return nft.metadata?.image_data ? import_crypto_nft_score_model7.PASS : [0, MaxPossibleImageScore];
   }
-}, "scoreNftImage");
-var scoreImage = /* @__PURE__ */ __name((image) => {
-  const score = [
-    0,
-    MaxPossibleImageScore
-  ];
+};
+var scoreImage = (image) => {
+  const score = [0, MaxPossibleImageScore];
   if (!image || typeof image !== "string" || !isValidUrl(image)) return score;
   (0, import_crypto_nft_score_model7.incrementTotal)(score);
   if (!isSecure(image)) return score;
@@ -245,13 +207,13 @@ var scoreImage = /* @__PURE__ */ __name((image) => {
   if (!isWeb3(image)) return score;
   (0, import_crypto_nft_score_model7.incrementTotal)(score);
   return score;
-}, "scoreImage");
+};
 
 // src/lib/rating/criteria/scoring/metadata/imageData.ts
 var import_crypto_nft_score_model8 = require("@xyo-network/crypto-nft-score-model");
 var import_svg_parser = require("svg-parser");
 var MaxPossibleImageDataScore = 1;
-var isValidImageData = /* @__PURE__ */ __name((image_data) => {
+var isValidImageData = (image_data) => {
   if (!image_data.startsWith("<svg")) return false;
   try {
     (0, import_svg_parser.parse)(image_data);
@@ -259,61 +221,46 @@ var isValidImageData = /* @__PURE__ */ __name((image_data) => {
   } catch {
     return false;
   }
-}, "isValidImageData");
-var scoreNftImageData = /* @__PURE__ */ __name((nft) => {
+};
+var scoreNftImageData = (nft) => {
   if (nft?.metadata?.image_data) {
     return scoreImageData(nft.metadata?.image_data);
   } else {
-    return nft.metadata?.image ? import_crypto_nft_score_model8.PASS : [
-      0,
-      MaxPossibleImageDataScore
-    ];
+    return nft.metadata?.image ? import_crypto_nft_score_model8.PASS : [0, MaxPossibleImageDataScore];
   }
-}, "scoreNftImageData");
-var scoreImageData = /* @__PURE__ */ __name((image_data) => {
-  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [
-    0,
-    MaxPossibleImageDataScore
-  ] : [
-    MaxPossibleImageDataScore,
-    MaxPossibleImageDataScore
-  ];
-}, "scoreImageData");
+};
+var scoreImageData = (image_data) => {
+  return !image_data || typeof image_data !== "string" || !isValidImageData(image_data) ? [0, MaxPossibleImageDataScore] : [MaxPossibleImageDataScore, MaxPossibleImageDataScore];
+};
 
 // src/lib/rating/criteria/scoring/metadata/name.ts
 var import_crypto_nft_score_model9 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftName = /* @__PURE__ */ __name((nft) => {
+var scoreNftName = (nft) => {
   return scoreName(nft.metadata?.name);
-}, "scoreNftName");
-var scoreName = /* @__PURE__ */ __name((name) => {
-  const score = [
-    0,
-    1
-  ];
+};
+var scoreName = (name) => {
+  const score = [0, 1];
   if (!name || typeof name !== "string") return score;
   return (0, import_crypto_nft_score_model9.incrementTotal)(score);
-}, "scoreName");
+};
 
 // src/lib/rating/criteria/scoring/metadata/youtubeUrl.ts
 var import_crypto_nft_score_model10 = require("@xyo-network/crypto-nft-score-model");
-var scoreNftYoutubeUrl = /* @__PURE__ */ __name((nft) => {
+var scoreNftYoutubeUrl = (nft) => {
   return scoreYoutubeUrl(nft?.metadata?.youtube_url);
-}, "scoreNftYoutubeUrl");
-var scoreYoutubeUrl = /* @__PURE__ */ __name((youtube_url) => {
+};
+var scoreYoutubeUrl = (youtube_url) => {
   if (youtube_url === void 0 || youtube_url === null) return import_crypto_nft_score_model10.PASS;
-  const score = [
-    0,
-    2
-  ];
+  const score = [0, 2];
   if (typeof youtube_url !== "string" || !isValidUrl(youtube_url)) return score;
   (0, import_crypto_nft_score_model10.incrementTotal)(score);
   if (!isSecure(youtube_url)) return score;
   return (0, import_crypto_nft_score_model10.incrementTotal)(score);
-}, "scoreYoutubeUrl");
+};
 
 // src/lib/rating/criteria/scoring/supply.ts
 var import_crypto_nft_score_model11 = require("@xyo-network/crypto-nft-score-model");
-var scoreSupply = /* @__PURE__ */ __name((nft) => {
+var scoreSupply = (nft) => {
   if (!nft.supply) return import_crypto_nft_score_model11.FAIL;
   if (typeof nft.supply !== "string") return import_crypto_nft_score_model11.FAIL;
   try {
@@ -321,11 +268,11 @@ var scoreSupply = /* @__PURE__ */ __name((nft) => {
   } catch {
     return import_crypto_nft_score_model11.FAIL;
   }
-}, "scoreSupply");
+};
 
 // src/lib/rating/criteria/scoring/tokenId.ts
 var import_crypto_nft_score_model12 = require("@xyo-network/crypto-nft-score-model");
-var scoreTokenId = /* @__PURE__ */ __name((nft) => {
+var scoreTokenId = (nft) => {
   if (!nft.tokenId) return import_crypto_nft_score_model12.FAIL;
   if (typeof nft.tokenId !== "string") return import_crypto_nft_score_model12.FAIL;
   try {
@@ -333,147 +280,92 @@ var scoreTokenId = /* @__PURE__ */ __name((nft) => {
   } catch {
     return import_crypto_nft_score_model12.FAIL;
   }
-}, "scoreTokenId");
+};
 
 // src/lib/rating/criteria/scoring/type.ts
 var import_crypto_nft_score_model13 = require("@xyo-network/crypto-nft-score-model");
-var scoreType = /* @__PURE__ */ __name((nft) => {
+var scoreType = (nft) => {
   if (!nft.type) return import_crypto_nft_score_model13.FAIL;
   if (typeof nft.type !== "string") return import_crypto_nft_score_model13.FAIL;
   const type = nft.type.toUpperCase();
   if (type !== "ERC721" && type !== "ERC1155") return import_crypto_nft_score_model13.FAIL;
   return import_crypto_nft_score_model13.PASS;
-}, "scoreType");
+};
 
 // src/lib/rating/criteria/scoringCriteria.ts
 var attributesScoringCriteria = {
-  Attributes: {
-    score: evaluateNftAttributes,
-    weight: 1
-  }
+  Attributes: { score: evaluateNftAttributes, weight: 1 }
 };
 var metadataScoringCriteria = {
-  "Animation URL": {
-    score: scoreNftAnimationUrl,
-    weight: 1
-  },
-  "Background Color": {
-    score: scoreNftBackgroundColor,
-    weight: 1
-  },
-  "Description": {
-    score: scoreNftDescription,
-    weight: 1
-  },
-  "External Url": {
-    score: scoreNftExternalUrl,
-    weight: 1
-  },
-  "Image": {
-    score: scoreNftImage,
-    weight: 1
-  },
-  "Image Data": {
-    score: scoreNftImageData,
-    weight: 1
-  },
-  "Name": {
-    score: scoreNftName,
-    weight: 1
-  },
-  "YouTube URL": {
-    score: scoreNftYoutubeUrl,
-    weight: 1
-  },
+  "Animation URL": { score: scoreNftAnimationUrl, weight: 1 },
+  "Background Color": { score: scoreNftBackgroundColor, weight: 1 },
+  "Description": { score: scoreNftDescription, weight: 1 },
+  "External Url": { score: scoreNftExternalUrl, weight: 1 },
+  "Image": { score: scoreNftImage, weight: 1 },
+  "Image Data": { score: scoreNftImageData, weight: 1 },
+  "Name": { score: scoreNftName, weight: 1 },
+  "YouTube URL": { score: scoreNftYoutubeUrl, weight: 1 },
   ...attributesScoringCriteria
 };
 var scoringCriteria = {
-  "Contract Address": {
-    score: scoreContractAddress,
-    weight: 1
-  },
-  "Supply": {
-    score: scoreSupply,
-    weight: 1
-  },
-  "Token Id": {
-    score: scoreTokenId,
-    weight: 1
-  },
-  "Type": {
-    score: scoreType,
-    weight: 1
-  },
+  "Contract Address": { score: scoreContractAddress, weight: 1 },
+  "Supply": { score: scoreSupply, weight: 1 },
+  "Token Id": { score: scoreTokenId, weight: 1 },
+  "Type": { score: scoreType, weight: 1 },
   ...metadataScoringCriteria
 };
 
 // src/lib/rating/analyzeNft.ts
-var analyzeNft = /* @__PURE__ */ __name(async (nft) => {
-  const result = Object.fromEntries(await Promise.all(Object.entries(scoringCriteria).map(async ([key, { score, weight }]) => {
-    const rawScore = await score(nft);
-    const weighted = rawScore.map((v) => v * weight);
-    return [
-      key,
-      weighted
-    ];
-  })));
+var analyzeNft = async (nft) => {
+  const result = Object.fromEntries(
+    await Promise.all(
+      Object.entries(scoringCriteria).map(async ([key, { score, weight }]) => {
+        const rawScore = await score(nft);
+        const weighted = rawScore.map((v) => v * weight);
+        return [key, weighted];
+      })
+    )
+  );
   return result;
-}, "analyzeNft");
+};
 
 // src/Diviner.ts
-var toNftScorePayload = /* @__PURE__ */ __name((nftInfo, scores) => {
+var toNftScorePayload = (nftInfo, scores) => {
   const { address, chainId, type } = nftInfo;
-  return {
-    address,
-    chainId,
-    schema: import_crypto_nft_payload_plugin.NftScoreSchema,
-    scores,
-    type
-  };
-}, "toNftScorePayload");
-var isNftScore = /* @__PURE__ */ __name((payload) => payload.schema === import_crypto_nft_payload_plugin.NftScoreSchema, "isNftScore");
+  return { address, chainId, schema: import_crypto_nft_payload_plugin.NftScoreSchema, scores, type };
+};
+var isNftScore = (payload) => payload.schema === import_crypto_nft_payload_plugin.NftScoreSchema;
 var NftScoreDiviner = class extends import_diviner_abstract.AbstractDiviner {
-  static {
-    __name(this, "NftScoreDiviner");
-  }
-  static configSchemas = [
-    ...super.configSchemas,
-    import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema
-  ];
+  static configSchemas = [...super.configSchemas, import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema];
   static defaultConfigSchema = import_crypto_nft_payload_plugin.NftScoreDivinerConfigSchema;
-  divineHandler = /* @__PURE__ */ __name(async (payloads) => {
+  divineHandler = async (payloads) => {
     const nftInfos = payloads?.filter(import_crypto_nft_payload_plugin.isNftInfo) ?? [];
-    const results = await Promise.all(nftInfos.map(async (nftInfo) => {
-      const [score, sourceHash] = await Promise.all([
-        // Analyze the NFT
-        toNftScorePayload(nftInfo, await analyzeNft(nftInfo)),
-        // Hash the source payload
-        import_payload_builder.PayloadBuilder.dataHash(nftInfo)
-      ]);
-      return {
-        ...score,
-        sources: [
-          sourceHash
-        ]
-      };
-    }));
+    const results = await Promise.all(
+      nftInfos.map(async (nftInfo) => {
+        const [score, sourceHash] = await Promise.all([
+          // Analyze the NFT
+          toNftScorePayload(nftInfo, await analyzeNft(nftInfo)),
+          // Hash the source payload
+          import_payload_builder.PayloadBuilder.dataHash(nftInfo)
+        ]);
+        return { ...score, sources: [sourceHash] };
+      })
+    );
     return results;
-  }, "divineHandler");
+  };
 };
 
 // src/Plugin.ts
 var import_crypto_nft_payload_plugin2 = require("@xyo-network/crypto-nft-payload-plugin");
 var import_payload_model = require("@xyo-network/payload-model");
 var import_payloadset_plugin = require("@xyo-network/payloadset-plugin");
-var NftScoreDivinerPlugin = /* @__PURE__ */ __name(() => (0, import_payloadset_plugin.createPayloadSetDivinerPlugin)({
-  required: {
-    [import_crypto_nft_payload_plugin2.NftSchema]: 1
-  },
-  schema: import_payload_model.PayloadSetSchema
-}, {
-  diviner: /* @__PURE__ */ __name(async (params) => {
-    const result = await NftScoreDiviner.create(params);
-    return result;
-  }, "diviner")
-}), "NftScoreDivinerPlugin");
+var NftScoreDivinerPlugin = () => (0, import_payloadset_plugin.createPayloadSetDivinerPlugin)(
+  { required: { [import_crypto_nft_payload_plugin2.NftSchema]: 1 }, schema: import_payload_model.PayloadSetSchema },
+  {
+    diviner: async (params) => {
+      const result = await NftScoreDiviner.create(params);
+      return result;
+    }
+  }
+);
 //# sourceMappingURL=index.cjs.map