@necrolab/dashboard 0.4.3

package/src/stores/utils.js

@@ -0,0 +1,554 @@
+import cities from "./cities.json";
+
+function generateStreetAddress() {
+    const streetTypes = [
+        "Street",
+        "Avenue",
+        "Drive",
+        "Road",
+        "Boulevard",
+        "Lane",
+        "Way",
+        "Circle",
+        "Court",
+        "Place",
+        "Terrace",
+        "Parkway",
+        "Trail",
+        "Path",
+        "Loop"
+    ];
+
+    const streetNames = [
+        // Common Family Names (reflecting historical property owners)
+        "Anderson",
+        "Bennett",
+        "Collins",
+        "Davidson",
+        "Edwards",
+        "Foster",
+        "Gregory",
+        "Harrison",
+        "Irving",
+        "Jensen",
+        "Kennedy",
+        "Lawrence",
+        "Mitchell",
+        "Nelson",
+        "Patterson",
+        "Richardson",
+        "Stevens",
+        "Thompson",
+        "Walker",
+        "Wilson",
+
+        // Local Geography (subtle features)
+        "Hidden Valley",
+        "Pleasant View",
+        "Rolling",
+        "Scenic",
+        "Shady Grove",
+        "Stone Gate",
+        "Sunset",
+        "Valley View",
+        "Willow Brook",
+        "Woodland",
+        "Green Valley",
+        "Highland",
+        "Hillside",
+        "Lake View",
+        "Meadow",
+        "North Point",
+        "Oak Grove",
+        "River Bend",
+        "Spring",
+        "Westfield",
+
+        // Historical References (industries, landmarks)
+        "Mill Creek",
+        "Old Farm",
+        "Pioneer",
+        "Railway",
+        "School House",
+        "Station",
+        "Trading Post",
+        "Village Green",
+        "Water Tower",
+        "Grist Mill",
+        "Forge",
+        "Quarry",
+        "Cotton Mill",
+        "Mill Stone",
+        "Factory",
+        "Foundry",
+        "Market",
+        "Old Post",
+        "Town Hall",
+        "Workshop",
+
+        // Community Features
+        "Chapel",
+        "Church",
+        "College",
+        "Commons",
+        "Garden",
+        "Library",
+        "Museum",
+        "Park Place",
+        "Town Square",
+        "University",
+        "Academy",
+        "Campus",
+        "Central",
+        "Civic Center",
+        "Community",
+        "Institute",
+        "School",
+        "Union",
+        "Village",
+        "Center",
+
+        // Native Flora (region-specific)
+        "Aspen",
+        "Birch",
+        "Cedar",
+        "Dogwood",
+        "Elm",
+        "Hickory",
+        "Juniper",
+        "Maple",
+        "Oak",
+        "Pine",
+        "Sycamore",
+        "Walnut",
+        "Willow",
+        "Beech",
+        "Chestnut",
+        "Hawthorn",
+        "Locust",
+        "Magnolia",
+        "Poplar",
+        "Spruce",
+
+        // Settlement Patterns
+        "Cottage",
+        "Farmstead",
+        "Homestead",
+        "Manor",
+        "Plantation",
+        "Ranch",
+        "Settlement",
+        "Estate",
+        "Frontier",
+        "Heritage",
+        "Colonial",
+        "Crossroads",
+        "Junction",
+        "Landing",
+        "Milestone",
+        "Outpost",
+        "Pioneer",
+        "Settlers",
+        "Township",
+        "Waypoint",
+
+        // Everyday Objects (historical context)
+        "Kettle",
+        "Lantern",
+        "Millstone",
+        "Pocket",
+        "Saddle",
+        "Wagon",
+        "Wheel",
+        "Basket",
+        "Bucket",
+        "Candle",
+
+        // Subtle Descriptive
+        "Clear",
+        "Fair",
+        "Golden",
+        "Green",
+        "Pleasant",
+        "Quiet",
+        "Silent",
+        "Summer",
+        "Sunny",
+        "Sweet",
+        "Tender",
+        "Gentle",
+        "Bright",
+        "Calm",
+        "Fresh",
+        "Kind",
+        "Pure",
+        "Simple",
+        "Soft",
+        "Warm",
+
+        // Local Culture
+        "Heritage",
+        "Legacy",
+        "Memory",
+        "Tradition",
+        "Harmony",
+        "Liberty",
+        "Unity",
+        "Freedom",
+        "Justice",
+        "Progress",
+        "Friendship",
+        "Goodwill",
+        "Honor",
+        "Peace",
+        "Prosperity",
+        "Spirit",
+        "Trust",
+        "Victory",
+        "Virtue",
+        "Welcome",
+
+        // Regional Industries
+        "Dairy",
+        "Granary",
+        "Harvest",
+        "Orchard",
+        "Pasture",
+        "Timber",
+        "Vineyard",
+        "Farming",
+        "Mining",
+        "Trading",
+        "Commerce",
+        "Industry",
+        "Labor",
+        "Market",
+        "Merchant",
+        "Production",
+        "Storage",
+        "Transport",
+        "Warehouse",
+        "Workshop",
+
+        // Practical Descriptors
+        "Branch",
+        "Corner",
+        "Crossing",
+        "Edge",
+        "Gate",
+        "Path",
+        "Ridge",
+        "Trail",
+        "Turn",
+        "Way",
+        "Bend",
+        "Bridge",
+        "Fork",
+        "Hill",
+        "Junction",
+        "Pass",
+        "Point",
+        "Route",
+        "Track",
+        "Walk",
+
+        // Time Periods
+        "Colonial",
+        "Federal",
+        "Heritage",
+        "Historic",
+        "Legacy",
+        "Modern",
+        "Old",
+        "Pioneer",
+        "Settler",
+        "Traditional",
+        "Ancient",
+        "Classic",
+        "Early",
+        "Former",
+        "Late",
+        "New",
+        "Past",
+        "Present",
+        "Timeless",
+        "Vintage"
+    ];
+
+    const numberSuffixes = ["st", "nd", "rd", "th"];
+    const directions = ["North", "South", "East", "West", "Northwest", "Northeast", "Southwest", "Southeast"];
+
+    const generateNumber = () => {
+        const num = Math.floor(Math.random() * 9998) + 1;
+        return num.toString().padStart(1, "0");
+    };
+
+    const getRandomElement = (array) => array[Math.floor(Math.random() * array.length)];
+
+    const generateBaseName = () => {
+        // 10% chance for numbered street
+        if (Math.random() < 0.1) {
+            const num = Math.floor(Math.random() * 200) + 1;
+            const suffix = numberSuffixes[num <= 3 ? num - 1 : 3];
+            return `${num}${suffix}`;
+        }
+
+        // 15% chance for directional prefix
+        if (Math.random() < 0.15) {
+            return `${getRandomElement(directions)} ${getRandomElement(streetNames)}`;
+        }
+
+        // 5% chance for compound name
+        if (Math.random() < 0.05) {
+            const first = getRandomElement(streetNames);
+            const second = getRandomElement(streetNames);
+            return first !== second ? `${first} ${second}` : first;
+        }
+
+        return getRandomElement(streetNames);
+    };
+
+    const houseNumber = generateNumber();
+    const streetName = generateBaseName();
+    const streetType = getRandomElement(streetTypes);
+
+    return `${houseNumber} ${streetName} ${streetType}`.trim().replace(/\s+/g, " ");
+}
+
+const sortAlphaNum = (a, b) => {
+    var reA = /[^a-zA-Z]/g;
+    var reN = /[^0-9]/g;
+    var AInt = parseInt(a, 10);
+    var BInt = parseInt(b, 10);
+
+    if (isNaN(AInt) && isNaN(BInt)) {
+        var aA = a.replace(reA, "");
+        var bA = b.replace(reA, "");
+        if (aA === bA) {
+            var aN = parseInt(a.replace(reN, ""), 10);
+            var bN = parseInt(b.replace(reN, ""), 10);
+            return aN === bN ? 0 : aN > bN ? 1 : -1;
+        } else {
+            return aA > bA ? 1 : -1;
+        }
+    } else if (isNaN(AInt)) {
+        //A is not an Int
+        return 1; //to make alphanumeric sort first return -1 here
+    } else if (isNaN(BInt)) {
+        //B is not an Int
+        return -1; //to make alphanumeric sort first return 1 here
+    } else {
+        return AInt > BInt ? 1 : -1;
+    }
+};
+
+const timeDifference = (date1, date2) => {
+    let dif = date1 - date2;
+    if (dif < 0) return "00:00";
+
+    const dayDif = Math.floor(dif / 1000 / 60 / 60 / 24);
+    dif -= dayDif * 1000 * 60 * 60 * 24;
+    const hourDif = Math.floor(dif / 1000 / 60 / 60);
+    dif -= hourDif * 1000 * 60 * 60;
+    const minDif = Math.floor(dif / 1000 / 60);
+    dif -= minDif * 1000 * 60;
+    const secDif = Math.floor(dif / 1000);
+
+    const strMin = String(minDif).padStart(2, "0");
+    const strSec = String(secDif).padStart(2, "0");
+    const str = `${strMin}:${strSec}`;
+    if (str === "NaN:NaN") return "00:00";
+    return str;
+};
+
+const parseEventUrl = (url) => {
+    if (!url.includes("https://")) {
+        return { eventId: url };
+    }
+    const urlRegex = /^.*?\/([^/?]+)(?:\?(.*))?$/i;
+    const [, eventId, queryString = ""] = url.match(urlRegex) || [];
+    const queryParams = new URLSearchParams(queryString);
+
+    return {
+        eventId: eventId,
+        eventDid: queryParams.get("did"),
+        clOrigin: queryParams.get("subchannel_id") || queryParams.get("CL_ORIGIN")
+    };
+};
+
+const isEU = (siteId) => !["US", "AU", "UK", "LN", "CA", "NZ", "IE"].includes(siteId.replaceAll("TM_", ""));
+
+const removeDuplicates = (arr) => [...new Set(arr)];
+
+const pickRandom = (arr) => arr[Math.floor(Math.random() * arr.length)];
+
+const fakeId = () => {
+    const cityInfo = pickRandom(cities.filter((x) => x[2] != "GA" && x[2] != "PR" && x[0] > 10000));
+
+    const profile = {
+        zipCode: String(cityInfo[0]),
+        address: generateStreetAddress()
+    };
+
+    profile.city = cityInfo[1];
+    profile.state = cityInfo[2];
+
+    return profile;
+};
+
+// Card type definitions with their patterns and gaps
+const CARD_TYPES = {
+    visa: {
+        pattern: /^4\d{12}(?:\d{3})?$/,
+        gaps: [4, 8, 12]
+    },
+    mastercard: {
+        pattern: /^5[1-5]\d{14}$/,
+        gaps: [4, 8, 12]
+    },
+    amex: {
+        pattern: /^3[47]\d{13}$/,
+        gaps: [4, 10]
+    }
+};
+
+// Implementation of Luhn algorithm for card number validation
+function luhnCheck(cardNumber) {
+    const digits = cardNumber.replace(/\D/g, "");
+    let sum = 0;
+    let isEven = false;
+
+    // Loop from right to left
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let digit = parseInt(digits[i], 10);
+
+        if (isEven) {
+            digit *= 2;
+            if (digit > 9) {
+                digit -= 9;
+            }
+        }
+
+        sum += digit;
+        isEven = !isEven;
+    }
+
+    return sum % 10 === 0;
+}
+
+const getCardType = (str) => {
+    switch (str?.[0]) {
+        default:
+        case "4":
+            return "Visa";
+        case "3":
+            return "Amex";
+        case "5":
+            return "Master";
+    }
+};
+
+// Format card number with proper spacing
+function formatCardNumber(cardNumber, gaps) {
+    try {
+        const cleanNumber = cardNumber.replace(/\D/g, "");
+        const formatted = cleanNumber.split("");
+
+        // Insert spaces at the specified gaps
+        gaps.forEach((gap, index) => {
+            if (formatted.length > gap + index) {
+                formatted.splice(gap + index, 0, " ");
+            }
+        });
+
+        return formatted.join("");
+    } catch {
+        return cardNumber;
+    }
+}
+
+// Main validation function
+function validateCard(cardNumber) {
+    const cleanNumber = cardNumber.replace(/\s+/g, "");
+    const type = getCardType(cleanNumber);
+    const cardTypeInfo = CARD_TYPES[type] || CARD_TYPES.visa; // Default to visa gaps if unknown
+
+    const isValid =
+        cleanNumber.length >= 13 && cleanNumber.length <= 19 && /^\d+$/.test(cleanNumber) && luhnCheck(cleanNumber);
+
+    return {
+        type,
+        invalid: !isValid,
+        formatted: formatCardNumber(cleanNumber, cardTypeInfo.gaps)
+    };
+}
+
+function sortTaskIds(a, b) {
+    const parseId = (id) => {
+        if (!id) return { prefix: "", num: -1 };
+
+        if (/^\d+$/.test(id)) {
+            return { prefix: "", num: parseInt(id, 10) };
+        }
+
+        const match = id.match(/^([A-Za-z-]+)(\d+)$/);
+        if (match) {
+            return { prefix: match[1], num: parseInt(match[2], 10) };
+        }
+
+        return { prefix: id, num: -1 };
+    };
+
+    const aInfo = parseId(a);
+    const bInfo = parseId(b);
+
+    if (aInfo.prefix !== bInfo.prefix) {
+        return aInfo.prefix.localeCompare(bInfo.prefix);
+    }
+
+    return aInfo.num - bInfo.num;
+}
+
+function betterSort(a, b) {
+    if (a === undefined || a === null) return b === undefined || b === null ? 0 : -1;
+    if (b === undefined || b === null) return 1;
+
+    const aStr = String(a);
+    const bStr = String(b);
+
+    if (!isNaN(aStr) && !isNaN(bStr)) {
+        return Number(aStr) - Number(bStr);
+    }
+
+    const aParts = aStr.split(/(\d+)/).filter(Boolean);
+    const bParts = bStr.split(/(\d+)/).filter(Boolean);
+
+    const len = Math.min(aParts.length, bParts.length);
+    for (let i = 0; i < len; i++) {
+        if (!isNaN(aParts[i]) && !isNaN(bParts[i])) {
+            const numA = parseInt(aParts[i], 10);
+            const numB = parseInt(bParts[i], 10);
+            if (numA !== numB) return numA - numB;
+        } else {
+            const cmp = aParts[i].localeCompare(bParts[i]);
+            if (cmp !== 0) return cmp;
+        }
+    }
+
+    return aParts.length - bParts.length;
+}
+
+export {
+    generateStreetAddress,
+    timeDifference,
+    sortAlphaNum,
+    parseEventUrl,
+    isEU,
+    removeDuplicates,
+    pickRandom,
+    fakeId,
+    getCardType,
+    validateCard,
+    sortTaskIds,
+    betterSort
+};

package/src/types/index.js

@@ -0,0 +1,42 @@
+/**
+ * @typedef {Object} Task
+ * @property {string} accountTag
+ * @property {boolean} active
+ * @property {boolean} agedAccount
+ * @property {string} createdAt
+ * @property {string} createdAt
+ * @property {boolean} doNotPay
+ * @property {string} email
+ * @property {string} eventCity
+ * @property {string} eventDate
+ * @property {string} eventId
+ * @property {string} eventImage
+ * @property {string} eventLocalDate
+ * @property {string} eventName
+ * @property {string} eventUrl
+ * @property {string} eventVenue
+ * @property {string} expirationTime
+ * @property {boolean} incapsulaBypass
+ * @property {boolean} isExpanded
+ * @property {boolean} loginAfterCart
+ * @property {boolean} manual
+ * @property {string} mode
+ * @property {string} openerLink
+ * @property {string} password
+ * @property {string} presaleCode
+ * @property {boolean} presaleMode
+ * @property {string} profileName
+ * @property {Array} profileTags
+ * @property {string} proxy
+ * @property {number} quantity
+ * @property {boolean} quickQueue
+ * @property {string} reservedTicketsList
+ * @property {boolean} selected
+ * @property {string} siteId
+ * @property {boolean} smartTimer
+ * @property {string} status
+ * @property {string} statusColor
+ * @property {string} taskId
+ * @property {string} venueName
+ * @property {string} _timeLeftString
+ */

package/src/utils/debug.js

@@ -0,0 +1 @@
+export const DEBUG = window.location.href.startsWith("http://localhost:5173");