@skyhelperbot/utils 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Naiyar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+
+### <p align="center"> Utility Package for <a href="https://github.com/imnaiyar/skyhelper">SkyHelper</a> bot.</p>
+
+This package contains various utilities for SkyHelper discord bot!
+
+Run this to install
+```
+npm install skyhelper-utils
+```
+
+**Documentation**: https://utils.skyhelper.xyz/

package/dist/classes/LeaderBoardCard.d.ts

@@ -0,0 +1,59 @@
+import type { userData, colorsType, LeaderboardOptions } from "../typings.js";
+/**
+ * Represents a Quiz Leaderboard Card. A class for generating a leaderboard card for a quiz or game.
+ * @returns - The generated image buffer.
+ */
+export declare class LeaderboardCard {
+    private usersData;
+    private background;
+    private abbreviateNumber;
+    private opacity;
+    private scoreMessage;
+    private colors;
+    constructor(options: LeaderboardOptions);
+    /**
+     * .setUsersData
+     * @param usersData ```js
+     * [{ top: int, avatar: "string", tag: "string", score: int}, games: int]
+     * ```
+     * @example setUsersData([{top:1,avatar:"https://someone-image.png",tag:"fivesobes",score:5, games:8}])
+     */
+    setUsersData(usersData: userData[]): this;
+    /**
+     * .setScoreMessage
+     * @param  message Set Custom Score Message
+     * @example setScoreMessage("Message")
+     */
+    setScoreMessage(message: string): this;
+    /**
+     * .setColors
+     * @param colors ```json
+     * {box: "hexcolor", username: "hexcolor", score: "hexcolor", firstRank: "hexcolor", secondRank: "hexcolor", thirdRank: "hexcolor"}
+     * ```
+     * @example
+     * setColors({ box: '#212121', username: '#ffffff', score: '#ffffff', firstRank: '#f7c716', secondRank: '#9e9e9e', thirdRank: '#94610f' })
+     */
+    setColors(colors: colorsType): this;
+    /**
+     * .setabbreviateNumber
+     * @param bool must be "true" or "false"
+     * @example setabbreviateNumber(true)
+     */
+    setabbreviateNumber(bool: boolean): this;
+    /**
+     * .setOpacity
+     * @param opacity must be between 0 and 1
+     * @example setOpacity(0.6)
+     */
+    setOpacity(opacity?: number): this;
+    /**
+     * .setBackground
+     * @param type "image" or "color"
+     * @param value "url" or "hexcolor"
+     * @example setBackground("image","https://someone-image.png")
+     * @example setBackground("color","#000")
+     */
+    setBackground(type: string, value: string): this;
+    build(): Promise<Buffer>;
+    private fillRoundRect;
+}

package/dist/classes/LeaderBoardCard.js

@@ -0,0 +1,249 @@
+import { createCanvas, loadImage, GlobalFonts } from "@napi-rs/canvas";
+import * as path from "node:path";
+/**
+ * Represents a Quiz Leaderboard Card. A class for generating a leaderboard card for a quiz or game.
+ * @returns - The generated image buffer.
+ */
+export class LeaderboardCard {
+    usersData;
+    background;
+    abbreviateNumber;
+    opacity;
+    scoreMessage;
+    colors;
+    constructor(options) {
+        this.usersData = options?.usersData || [];
+        this.background = {
+            type: "none",
+            background: "none",
+        };
+        this.abbreviateNumber = false;
+        this.opacity = 0;
+        this.scoreMessage = "";
+        this.colors = options?.colors || {
+            box: "#212121",
+            username: "#ffffff",
+            score: "#ffffff",
+            firstRank: "#f7c716",
+            secondRank: "#9e9e9e",
+            thirdRank: "#94610f",
+        };
+    }
+    /**
+     * .setUsersData
+     * @param usersData ```js
+     * [{ top: int, avatar: "string", tag: "string", score: int}, games: int]
+     * ```
+     * @example setUsersData([{top:1,avatar:"https://someone-image.png",tag:"fivesobes",score:5, games:8}])
+     */
+    setUsersData(usersData) {
+        if (usersData.length > 10) {
+            throw new Error("setUsersData values cannot be greater than 10.");
+        }
+        this.usersData = usersData;
+        return this;
+    }
+    /**
+     * .setScoreMessage
+     * @param  message Set Custom Score Message
+     * @example setScoreMessage("Message")
+     */
+    setScoreMessage(message) {
+        this.scoreMessage = message;
+        return this;
+    }
+    /**
+     * .setColors
+     * @param colors ```json
+     * {box: "hexcolor", username: "hexcolor", score: "hexcolor", firstRank: "hexcolor", secondRank: "hexcolor", thirdRank: "hexcolor"}
+     * ```
+     * @example
+     * setColors({ box: '#212121', username: '#ffffff', score: '#ffffff', firstRank: '#f7c716', secondRank: '#9e9e9e', thirdRank: '#94610f' })
+     */
+    setColors(colors) {
+        this.colors = colors;
+        return this;
+    }
+    /**
+     * .setabbreviateNumber
+     * @param bool must be "true" or "false"
+     * @example setabbreviateNumber(true)
+     */
+    setabbreviateNumber(bool) {
+        if (typeof bool !== "boolean") {
+            throw new Error("You must give a abbreviate number true or false argument.");
+        }
+        this.abbreviateNumber = bool;
+        return this;
+    }
+    /**
+     * .setOpacity
+     * @param opacity must be between 0 and 1
+     * @example setOpacity(0.6)
+     */
+    setOpacity(opacity = 0) {
+        if (opacity >= 0 && opacity <= 1) {
+            this.opacity = opacity;
+            return this;
+        }
+        else {
+            throw new Error("The value of the opacity of setOpacity method must be between 0 and 1 (0 and 1 included).");
+        }
+    }
+    /**
+     * .setBackground
+     * @param type "image" or "color"
+     * @param value "url" or "hexcolor"
+     * @example setBackground("image","https://someone-image.png")
+     * @example setBackground("color","#000")
+     */
+    setBackground(type, value) {
+        if (type === "color") {
+            if (/^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/.test(value)) {
+                this.background.type = "color";
+                this.background.background = value;
+                return this;
+            }
+            else {
+                throw new Error("Invalid color for the second argument in setForeground method. You must give a hexadecimal color.");
+            }
+        }
+        else if (type === "image") {
+            this.background.type = "image";
+            this.background.background = value;
+            return this;
+        }
+        else {
+            throw new Error("The first argument of setBackground must be 'color' or 'image'.");
+        }
+    }
+    async build() {
+        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/circularstd-black.otf`), "circular-std");
+        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-jp-black.ttf`), "noto-sans-jp");
+        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-black.ttf`), "noto-sans");
+        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notoemoji-bold.ttf`), "noto-emoji");
+        GlobalFonts.registerFromPath(path.join(__dirname, `../../shared/fonts/notosans-kr-black.ttf`), "noto-sans-kr");
+        const abbreviateNumber = (value) => {
+            let newValue = value;
+            if (value >= 1000) {
+                const suffixes = ["", "K", "M", "B", "T"];
+                const suffixNum = Math.floor(("" + value).length / 3);
+                let shortValue = "";
+                for (let precision = 2; precision >= 1; precision--) {
+                    shortValue = parseFloat((suffixNum != 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));
+                    const dotLessShortValue = (shortValue + "").replace(/[^a-zA-Z 0-9]+/g, "");
+                    if (dotLessShortValue.length <= 2) {
+                        break;
+                    }
+                }
+                if (typeof shortValue === "number" && shortValue % 1 != 0)
+                    shortValue = shortValue.toFixed(1);
+                newValue = shortValue + suffixes[suffixNum];
+            }
+            return newValue.toString();
+        };
+        const yuksek = this.usersData.length * 74.5;
+        const canvas = createCanvas(680, yuksek);
+        const ctx = canvas.getContext("2d");
+        ctx.globalAlpha = 1;
+        if (this.background.type === "color") {
+            ctx.fillStyle = this.background.background;
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+        }
+        else if (this.background.type === "image") {
+            try {
+                ctx.drawImage(await loadImage(this.background.background), 0, 0, canvas.width, canvas.height);
+            }
+            catch {
+                throw new Error("The image given in the second parameter of the setBackground method is not valid or you are not connected to the internet.");
+            }
+        }
+        if (this.usersData) {
+            let Box_Y = 0, Avatar_Y = 0, Tag_Y = 45, XP_Y = 45, Level_Y = 30, Rank_Y = 45;
+            for (let i = 0; i < this.usersData.length; i++) {
+                ctx.save();
+                ctx.fillStyle = this.colors.box;
+                ctx.globalAlpha = this.opacity;
+                this.fillRoundRect(ctx, 0, Box_Y, canvas.width, 70, 15, true, false);
+                ctx.globalAlpha = 1;
+                try {
+                    const avatar = await loadImage(this.usersData[i].avatar);
+                    ctx.clip();
+                    ctx.drawImage(avatar, 0, Avatar_Y, 70, 70);
+                }
+                catch (err) {
+                    console.error("Failed to load avatar", err);
+                }
+                ctx.shadowBlur = 10;
+                ctx.shadowOffsetX = 8;
+                ctx.shadowOffsetY = 6;
+                ctx.shadowColor = "#0a0a0a";
+                ctx.fillStyle = this.colors.username;
+                ctx.font = `bold 25px circular-std, noto-emoji, noto-sans-jp, noto-sans, noto-sans-kr`;
+                ctx.textAlign = "left";
+                ctx.fillText(this.usersData[i].tag, 80, Tag_Y, 260);
+                ctx.fillStyle = this.colors.score;
+                ctx.font = `bold 20px circular-std, noto-emoji, noto-sans-jp, noto-sans, noto-sans-kr`;
+                ctx.textAlign = "right";
+                ctx.fillText(`${this.scoreMessage} ${this.abbreviateNumber == true ? `${abbreviateNumber(this.usersData[i].score)}` : `${this.usersData[i].score}`}/${this.abbreviateNumber == true ? `${abbreviateNumber(this.usersData[i].games)}` : `${this.usersData[i].games}`}`, 560, XP_Y, 200);
+                if (this.usersData[i].top === 1) {
+                    ctx.fillStyle = this.colors.firstRank;
+                }
+                else if (this.usersData[i].top === 2) {
+                    ctx.fillStyle = this.colors.secondRank;
+                }
+                else if (this.usersData[i].top === 3) {
+                    ctx.fillStyle = this.colors.thirdRank;
+                }
+                ctx.font = `bold 30px circular-std, noto-emoji, noto-sans-jp, noto-sans, noto-sans-kr`;
+                ctx.textAlign = "right";
+                ctx.fillText("#" + this.usersData[i].top, 660, Rank_Y, 75);
+                Box_Y = Box_Y + 75;
+                Avatar_Y = Avatar_Y + 75;
+                Tag_Y = Tag_Y + 75;
+                XP_Y = XP_Y + 75;
+                Level_Y = Level_Y + 75;
+                Rank_Y = Rank_Y + 75;
+                ctx.restore();
+            }
+        }
+        else {
+            ctx.font = `bold 40px circular-std, noto-emoji, noto-sans-jp, noto-sans, noto-sans-kr`;
+            ctx.fillStyle = "#ffffff";
+            ctx.textAlign = "center";
+            ctx.shadowBlur = 10;
+            ctx.shadowOffsetX = 8;
+            ctx.shadowOffsetY = 6;
+            ctx.shadowColor = "#0a0a0a";
+            ctx.fillText("Not found!", 340, 370, 500);
+        }
+        return canvas.toBuffer("image/png");
+    }
+    fillRoundRect(ctx, x, y, w, h, r, f, s) {
+        if (typeof r === "number") {
+            r = { tl: r, tr: r, br: r, bl: r };
+        }
+        else {
+            const defaultRadius = { tl: 0, tr: 0, br: 0, bl: 0 };
+            for (const side in defaultRadius) {
+                r[side] =
+                    r[side] || defaultRadius[side];
+            }
+        }
+        ctx.beginPath();
+        ctx.moveTo(x + r.tl, y);
+        ctx.lineTo(x + w - r.tr, y);
+        ctx.quadraticCurveTo(x + w, y, x + w, y + r.tr);
+        ctx.lineTo(x + w, y + h - r.br);
+        ctx.quadraticCurveTo(x + w, y + h, x + w - r.br, y + h);
+        ctx.lineTo(x + r.bl, y + h);
+        ctx.quadraticCurveTo(x, y + h, x, y + h - r.bl);
+        ctx.lineTo(x, y + r.tl);
+        ctx.quadraticCurveTo(x, y, x + r.tl, y);
+        ctx.closePath();
+        if (f)
+            ctx.fill();
+        if (s)
+            ctx.stroke();
+    }
+}

package/dist/classes/SkytimesUtils.d.ts

@@ -0,0 +1,73 @@
+import moment from "moment-timezone";
+import "moment-duration-format";
+import { eventData } from "../constants/eventDatas.js";
+type EventKey = keyof typeof eventData;
+/**
+ * Utilities for skytimes
+ */
+export declare class SkytimesUtils {
+    /** Get all occurences of an event for the given date
+     * @param eventTime The moment date for which to get all occurences
+     * @param interval The interval between the event occurence's
+     */
+    static getAllTimes(eventTime: moment.Moment, interval?: number): string;
+    /**
+     * Get the date in moment on which the event will occur (if it's not a daily event)
+     * @param event The event for which to get the date-time
+     */
+    private static getOccurenceDay;
+    /**
+     * Get the next occurence of the event relative to now
+     * @param eventName The key of the event
+     */
+    private static getNextEventOccurrence;
+    /**
+     * Get the details about an event, their status, next occurence, al occurences for the day
+     * @param key The event key
+     */
+    static getEventDetails(key: EventKey): EventDetails;
+    /**
+     * Same as {@apilink SkytimesUtils.getEventDetails | getEventDetails} but for all of the events
+     * @returns An array of event details
+     */
+    static allEventDetails(): [EventKey, EventDetails][];
+    /**
+     * Returns the event status of a given event
+     * @param event The event to get the status for
+     * @param nextOccurence The next occurence of the event relative to "now"
+     * @returns The event status (or null if there is no active duration)
+     */
+    static getEventStatus(event: (typeof eventData)[keyof typeof eventData], nextOccurence: moment.Moment): Times;
+}
+export interface BaseTimes {
+    /** Whether the event is active or not */
+    active: boolean;
+    /** The time when the event starts */
+    nextTime: moment.Moment;
+    /** This will be the countdown for when the event ends if it's active,
+     *  otherwise it'll be the countdown to the next occurence
+     */
+    duration: string;
+}
+export interface ActiveTimes extends BaseTimes {
+    active: true;
+    /** The time when the event started if active */
+    startTime: moment.Moment;
+    /** The time when the event ends if active */
+    endTime: moment.Moment;
+}
+export interface NotActiveTimes extends BaseTimes {
+    active: false;
+    /** The time when the event started if active */
+    startTime?: moment.Moment;
+    /** The time when the event ends if active */
+    endTime?: moment.Moment;
+}
+export type Times = ActiveTimes | NotActiveTimes;
+export interface EventDetails {
+    event: (typeof eventData)[EventKey];
+    nextOccurence: moment.Moment;
+    allOccurences: string;
+    status: Times;
+}
+export {};

package/dist/classes/SkytimesUtils.js

@@ -0,0 +1,119 @@
+import { Base, time } from "discord.js";
+import moment from "moment-timezone";
+import "moment-duration-format";
+import { eventData } from "../constants/eventDatas.js";
+/**
+ * Utilities for skytimes
+ */
+export class SkytimesUtils {
+    /** Get all occurences of an event for the given date
+     * @param eventTime The moment date for which to get all occurences
+     * @param interval The interval between the event occurence's
+     */
+    static getAllTimes(eventTime, interval) {
+        const clonedTime = eventTime.clone();
+        const timeBuilt = [];
+        while (eventTime.date() === clonedTime.date()) {
+            timeBuilt.push(time(clonedTime.toDate(), "t"));
+            clonedTime.add(interval || 0, "minutes");
+        }
+        return timeBuilt.join(" • ");
+    }
+    /**
+     * Get the date in moment on which the event will occur (if it's not a daily event)
+     * @param event The event for which to get the date-time
+     */
+    static getOccurenceDay(event) {
+        const nextOccurrence = moment().tz("America/Los_Angeles").startOf("day").add(event.offset, "minutes"); // Start with the offset from the beginning of the day
+        if (event.occursOn) {
+            // If the event occurs on specific weekdays
+            if (event.occursOn.weekDays) {
+                while (!event.occursOn.weekDays.includes(nextOccurrence.isoWeekday())) {
+                    nextOccurrence.add(1, "day");
+                }
+            }
+            // If the event occurs on a specific day of the month
+            if (event.occursOn.dayOfTheMonth) {
+                while (nextOccurrence.date() !== event.occursOn.dayOfTheMonth) {
+                    nextOccurrence.add(1, "day");
+                }
+            }
+        }
+        return nextOccurrence;
+    }
+    /**
+     * Get the next occurence of the event relative to now
+     * @param eventName The key of the event
+     */
+    static getNextEventOccurrence(eventName) {
+        const event = eventData[eventName];
+        if (!event)
+            throw new Error("Unknow Event");
+        const now = moment().tz("America/Los_Angeles"); // Current time
+        const nextOccurrence = this.getOccurenceDay(event);
+        // Loop to calculate the next occurrence based on the interval
+        while (nextOccurrence.isBefore(now)) {
+            nextOccurrence.add(event.interval || 0, "minutes");
+        }
+        return nextOccurrence;
+    }
+    /**
+     * Get the details about an event, their status, next occurence, al occurences for the day
+     * @param key The event key
+     */
+    static getEventDetails(key) {
+        const nextOccurence = this.getNextEventOccurrence(key);
+        return {
+            event: eventData[key],
+            nextOccurence,
+            allOccurences: this.getAllTimes(this.getOccurenceDay(eventData[key]), eventData[key].interval),
+            status: this.getEventStatus(eventData[key], nextOccurence),
+        };
+    }
+    /**
+     * Same as {@apilink SkytimesUtils.getEventDetails | getEventDetails} but for all of the events
+     * @returns An array of event details
+     */
+    static allEventDetails() {
+        const keys = Object.keys(eventData).sort((a, b) => eventData[a].index - eventData[b].index);
+        const occurences = [];
+        for (const key of keys) {
+            occurences.push([key, this.getEventDetails(key)]);
+        }
+        return occurences;
+    }
+    /**
+     * Returns the event status of a given event
+     * @param event The event to get the status for
+     * @param nextOccurence The next occurence of the event relative to "now"
+     * @returns The event status (or null if there is no active duration)
+     */
+    static getEventStatus(event, nextOccurence) {
+        const now = moment().tz("America/Los_Angeles");
+        const BASE = {
+            active: false,
+            nextTime: nextOccurence,
+            duration: moment.duration(nextOccurence.diff(now)).format("d[d] h[h] m[m] s[s]"),
+        };
+        if (!event.duration)
+            return BASE;
+        // Substract the interval because nextOccurence always calculates the next upcoming event
+        // So we substract the interval to get the last occurence, and add the active duration to it, and check if now is between those
+        const start = nextOccurence.clone().subtract(event.interval || 0, "minutes");
+        const end = start.clone().add(event.duration, "minutes");
+        // When active
+        if (now.isBetween(start, end)) {
+            return {
+                active: true,
+                startTime: start,
+                endTime: end,
+                // TODO: This maybe not needed as nextoccurence is inncluded in original object returned from `eventOccurence()`
+                nextTime: nextOccurence,
+                duration: moment.duration(end.diff(now)).format("d[d] h[h] m[m] s[s]"),
+            };
+        }
+        else {
+            return BASE;
+        }
+    }
+}

package/dist/classes/UpdateEvent.d.ts

@@ -0,0 +1,30 @@
+import type { SpecialEventData } from "../typings.js";
+/**
+ * @class
+ * @classdesc A class to update Events details in the client constructor
+ * @method update Updates the event details
+ */
+export declare class UpdateEvent {
+    readonly data: SpecialEventData;
+    constructor(data: SpecialEventData);
+    /**
+     * @param name Name of the event
+     */
+    setName(name: string): this;
+    /**
+     * @param date Start date of the Event. Format DD-MM-YYYY
+     * @example
+     * new UpdateEvent().setDate('22-09-2023')
+     */
+    setStart(date: string): this;
+    /**
+     * @param date End date of the Event. Format DD-MM-YYYY
+     * @example
+     * new UpdateEvent().setDate('22-09-2023')
+     */
+    setEnd(date: string): this;
+    /**
+     * @returns The updated event
+     */
+    update(): Promise<SpecialEventData>;
+}

package/dist/classes/UpdateEvent.js

@@ -0,0 +1,52 @@
+import moment from "moment-timezone";
+/**
+ * @class
+ * @classdesc A class to update Events details in the client constructor
+ * @method update Updates the event details
+ */
+export class UpdateEvent {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    /**
+     * @param name Name of the event
+     */
+    setName(name) {
+        if (!name || typeof name !== "string") {
+            throw new TypeError("Name must be a non-empty string.");
+        }
+        this.data.name = name;
+        return this;
+    }
+    /**
+     * @param date Start date of the Event. Format DD-MM-YYYY
+     * @example
+     * new UpdateEvent().setDate('22-09-2023')
+     */
+    setStart(date) {
+        if (!date || typeof date !== "string") {
+            throw new TypeError("Date must be a non-empty string.");
+        }
+        this.data.startDate = date;
+        return this;
+    }
+    /**
+     * @param date End date of the Event. Format DD-MM-YYYY
+     * @example
+     * new UpdateEvent().setDate('22-09-2023')
+     */
+    setEnd(date) {
+        if (!date || typeof date !== "string") {
+            throw new TypeError("Date must be a non-empty string.");
+        }
+        this.data.endDate = date;
+        return this;
+    }
+    /**
+     * @returns The updated event
+     */
+    async update() {
+        return await this.data.save();
+    }
+}

package/dist/classes/UpdateTs.d.ts

@@ -0,0 +1,35 @@
+import type { TSData } from "../typings.js";
+/**
+ * @class
+ * @classdesc A class to update traveling spirit details in the client constructor
+ * @method update updates the ts details
+ * @returns {Object}
+ */
+export declare class UpdateTS {
+    readonly data: TSData;
+    constructor(data: TSData);
+    /**
+     * Sets the name of the TS
+     * @param name Name of the returning TS
+     */
+    setName(name: string): this;
+    /**
+     * Sets the visit date of the ts
+     * @param date Returnig date. Format: DD-MM-YYYY
+     */
+    setVisit(date: string): this;
+    /**
+     * Sets the value of the t spirit
+     * @param value The value of the spirit in the spiritsData
+     */
+    setValue(value: string): this;
+    /**
+     * Sets the index of the returning ts
+     * @param index The returning index of the TS
+     */
+    setIndex(index: number): this;
+    /**
+     * returns the updated ts details
+     */
+    update(): Promise<TSData>;
+}