@koralabs/kora-labs-common 5.1.24 → 5.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@koralabs/kora-labs-common",
-    "version": "5.1.24",
+    "version": "5.1.26",
     "description": "Kora Labs Common Utilities",
     "main": "index.js",
     "types": "index.d.ts",

package/protectedWords/index.d.ts

@@ -1,10 +1,4 @@
 import { AvailabilityResponse, ReservedOrProtected } from '../handles/interfaces';
-declare global {
-    interface String {
-        includesSingularOrPlural(word: string): boolean;
-        replaceSingularOrPlural(word: string, replacement: string): string;
-    }
-}
 export declare class ProtectedWords {
     static protectedHandles: ReservedOrProtected;
     static readLock: boolean;

package/protectedWords/index.js

@@ -5,17 +5,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProtectedWords = void 0;
 const pluralize_esm_1 = __importDefault(require("pluralize-esm"));
-const protectedWords_1 = require("./protectedWords");
-const utils_1 = require("../utils");
-const interfaces_1 = require("../handles/interfaces");
 const constants_1 = require("../handles/constants");
-String.prototype.includesSingularOrPlural = function (word) {
+const interfaces_1 = require("../handles/interfaces");
+const utils_1 = require("../utils");
+const protectedWords_1 = require("./protectedWords");
+const includesSingularOrPlural = (handle, word) => {
     const singPlur = ProtectedWords.setSingular(word);
-    return this.includes(singPlur.singular) || this.includes(singPlur.plural);
+    return handle.includes(singPlur.singular) || handle.includes(singPlur.plural);
 };
-String.prototype.replaceSingularOrPlural = function (word, replacement) {
+const replaceSingularOrPlural = (handle, word, replacement) => {
     const singPlur = ProtectedWords.setSingular(word);
-    return this.replace(singPlur.singular, replacement).replace(singPlur.plural, replacement);
+    return handle.replace(singPlur.singular, replacement).replace(singPlur.plural, replacement);
 };
 class ProtectedWords {
     static async checkAvailability(handle) {
@@ -106,7 +106,7 @@ class ProtectedWords {
                 foundWord = entry.word;
                 return (entry.position == 'any' &&
                     !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
-                    h.includesSingularOrPlural(entry.word));
+                    includesSingularOrPlural(h, entry.word));
             })) {
                 return { protected: true, words: [foundWord] };
             }
@@ -118,7 +118,7 @@ class ProtectedWords {
                 foundWord = entry.word;
                 return (entry.position == 'beginswith' &&
                     h.startsWith(entry.word) &&
-                    !'aeiou'.includes((_a = h.replaceSingularOrPlural(entry.word, '')) === null || _a === void 0 ? void 0 : _a.charAt(0)) &&
+                    !'aeiou'.includes((_a = replaceSingularOrPlural(h, entry.word, '')) === null || _a === void 0 ? void 0 : _a.charAt(0)) &&
                     !((_b = entry.exceptions) === null || _b === void 0 ? void 0 : _b.some((exc) => h.includes(exc))));
             })) {
                 return { protected: true, words: [foundWord] };
@@ -138,13 +138,13 @@ class ProtectedWords {
             let foundWords = '';
             if (hatespeechEntries.some((entry) => {
                 var _a;
-                return (h.includesSingularOrPlural(entry.word) &&
+                return (includesSingularOrPlural(h, entry.word) &&
                     // It's a hatespeech target and includes a hatespeech modifier (check exceptions)
                     !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
                     hatespeechWords.some((hateWord) => {
                         var _a;
                         foundWords = `${entry.word},${hateWord.word}`;
-                        return (h.replaceSingularOrPlural(entry.word, ' ').includes(hateWord.word) &&
+                        return (replaceSingularOrPlural(h, entry.word, ' ').includes(hateWord.word) &&
                             !((_a = hateWord.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
                             // If it's a vulnerable target, a positive word is fine
                             !(entry.algorithms.includes('vulnerable') && hateWord.canBePositive) &&
@@ -176,13 +176,13 @@ class ProtectedWords {
             if ([...suggestiveEntries, ...vulnerableEntries].some((entry) => {
                 var _a;
                 // is combined with a suggestive word, or another suggestive entry (from the same badwords list), or it's a modifier + `pp`
-                return (h.includesSingularOrPlural(entry.word) &&
+                return (includesSingularOrPlural(h, entry.word) &&
                     !((_a = entry.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
                     (suggestiveWords.some((s) => {
                         var _a;
                         // is combined with a suggestive word (check exceptions)
                         foundWords = `${entry.word},${s.word}`;
-                        return (h.replaceSingularOrPlural(entry.word, ' ').includes(s.word) &&
+                        return (replaceSingularOrPlural(h, entry.word, ' ').includes(s.word) &&
                             !((_a = s.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))) &&
                             !(entry.algorithms.includes('vulnerable') && s.canBePositive));
                     }) ||
@@ -191,28 +191,26 @@ class ProtectedWords {
                             // is combined with another suggestive entry from the badwords list (check exceptions)
                             foundWords = `${entry.word},${s.word}`;
                             return (s != entry &&
-                                h.replaceSingularOrPlural(entry.word, ' ').includesSingularOrPlural(s.word) &&
+                                replaceSingularOrPlural(h, entry.word, ' ') && includesSingularOrPlural(h, s.word) &&
                                 !((_a = s.exceptions) === null || _a === void 0 ? void 0 : _a.some((exc) => h.includes(exc))));
                         }) ||
-                        modifiers.some((mod) => h.replaceSingularOrPlural(entry.word, ' ').includes(mod.word) &&
+                        modifiers.some((mod) => replaceSingularOrPlural(h, entry.word, ' ').includes(mod.word) &&
                             // If it can be a positive modifier, like "love", then vulnerable targets are OK
                             !(entry.algorithms.includes('vulnerable') &&
                                 mod.canBePositive &&
                                 !specialCaseVulnWords.some((spec) => {
                                     // it's a modifier + `pp` - This is a hint that it's not a good phrase like "tinypreteenpp"
                                     foundWords = `${entry.word},${mod.word},${spec}`;
-                                    return h
-                                        .replaceSingularOrPlural(entry.word, ' ')
-                                        .replaceSingularOrPlural(mod.word, ' ')
-                                        .includes(spec);
+                                    return replaceSingularOrPlural(h, entry.word, ' ') &&
+                                        replaceSingularOrPlural(h, mod.word, ' ') &&
+                                        h.includes(spec);
                                 })) &&
                             specialCaseVulnWords.some((spec) => {
                                 // it's a modifier + `pp` - This is a hint that it's not a good phrase like "tinypreteenpp"
                                 foundWords = `${entry.word},${mod.word},${spec}`;
-                                return h
-                                    .replaceSingularOrPlural(entry.word, ' ')
-                                    .replaceSingularOrPlural(mod.word, ' ')
-                                    .includes(spec);
+                                return replaceSingularOrPlural(h, entry.word, ' ') &&
+                                    replaceSingularOrPlural(h, mod.word, ' ') &&
+                                    h.includes(spec);
                             }))));
             })) {
                 return { protected: true, words: foundWords.split(',') };
@@ -329,7 +327,7 @@ class ProtectedWords {
                     // if over 3 chars, check anywhere in the word
                     (m.word.length > 3 &&
                         handle.includes(entry.word) &&
-                        handle.replaceSingularOrPlural(entry.word, ' ').includes(m.word))));
+                        replaceSingularOrPlural(handle, entry.word, ' ').includes(m.word))));
         }))) {
             return { badword: true, words: foundWords.split(',') };
         }

package/repositories/interfaces.d.ts

@@ -37,6 +37,17 @@ export interface AuthGrant {
     challengeMethod?: ChallengeMethod;
     revokeReason?: string;
 }
+export interface MerchOrder {
+    tx_id: string;
+    holder_address: string;
+    workflow_status: string;
+    order_status?: string;
+    terms_accepted: boolean;
+    created_at: number;
+    ada_market_value: string;
+    lovelace_cost: string;
+    order_id?: number;
+}
 export type Permission = 'subhandle.mint' | 'subhandle.mintmyown' | 'handles.login';
 export type FriendlyPermissions = Record<string, string>;
 export type ChallengeMethod = 'sha256' | 'plain';