@vencord/types 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# Vencord Types
+
+Typings for Vencord's api, published to npm
+
+```sh
+npm i @vencord/types
+
+yarn add @vencord/types
+
+pnpm add @vencord/types
+```

package/dist/Vencord.d.ts

@@ -0,0 +1,28 @@
+/*!
+ * Vencord, a modification for Discord's desktop app
+ * Copyright (c) 2022 Vendicated and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+export * as Api from "./api";
+export * as Plugins from "./plugins";
+export * as Util from "./utils";
+export * as QuickCss from "./utils/quickCss";
+export * as Updater from "./utils/updater";
+export * as Webpack from "./webpack";
+export { PlainSettings, Settings };
+import "./utils/quickCss";
+import "./webpack/patchWebpack";
+import { PlainSettings, Settings } from "./api/settings";
+export declare let Components: any;

package/dist/VencordNative.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="standalone-electron-types" />
+/// <reference types="node" />
+import { IpcRenderer } from "electron";
+declare const _default: {
+    getVersions: () => NodeJS.ProcessVersions;
+    ipc: {
+        send(event: string, ...args: any[]): void;
+        sendSync<T = any>(event: string, ...args: any[]): T;
+        on(event: string, listener: Parameters<IpcRenderer["on"]>[1]): void;
+        off(event: string, listener: Parameters<IpcRenderer["off"]>[1]): void;
+        invoke<T_1 = any>(event: string, ...args: any[]): Promise<T_1>;
+    };
+};
+export default _default;

package/dist/api/Badges.d.ts

@@ -0,0 +1,62 @@
+import { User } from "discord-types/general";
+import { ComponentType, HTMLProps } from "react";
+export declare enum BadgePosition {
+    START = 0,
+    END = 1
+}
+export interface ProfileBadge {
+    /** The tooltip to show on hover. Required for image badges */
+    description?: string;
+    /** Custom component for the badge (tooltip not included) */
+    component?: ComponentType<ProfileBadge & BadgeUserArgs>;
+    /** The custom image to use */
+    image?: string;
+    link?: string;
+    /** Action to perform when you click the badge */
+    onClick?(): void;
+    /** Should the user display this badge? */
+    shouldShow?(userInfo: BadgeUserArgs): boolean;
+    /** Optional props (e.g. style) for the badge, ignored for component badges */
+    props?: HTMLProps<HTMLImageElement>;
+    /** Insert at start or end? */
+    position?: BadgePosition;
+    /** The badge name to display, Discord uses this. Required for component badges */
+    key?: string;
+}
+/**
+ * Register a new badge with the Badges API
+ * @param badge The badge to register
+ */
+export declare function addBadge(badge: ProfileBadge): void;
+/**
+ * Unregister a badge from the Badges API
+ * @param badge The badge to remove
+ */
+export declare function removeBadge(badge: ProfileBadge): boolean;
+/**
+ * Inject badges into the profile badges array.
+ * You probably don't need to use this.
+ */
+export declare function _getBadges(args: BadgeUserArgs): ProfileBadge[];
+export interface BadgeUserArgs {
+    user: User;
+    profile: Profile;
+    premiumSince: Date;
+    premiumGuildSince?: Date;
+}
+interface ConnectedAccount {
+    type: string;
+    id: string;
+    name: string;
+    verified: boolean;
+}
+interface Profile {
+    connectedAccounts: ConnectedAccount[];
+    premiumType: number;
+    premiumSince: string;
+    premiumGuildSince?: any;
+    lastFetched: number;
+    profileFetchFailed: boolean;
+    application?: any;
+}
+export {};

package/dist/api/Commands/commandHelpers.d.ts

@@ -0,0 +1,20 @@
+import { Message } from "discord-types/general";
+import type { PartialDeep } from "type-fest";
+import { Argument } from "./types";
+export declare function generateId(): string;
+/**
+ * Send a message as Clyde
+ * @param {string} channelId ID of channel to send message to
+ * @param {Message} message Message to send
+ * @returns {Message}
+ */
+export declare function sendBotMessage(channelId: string, message: PartialDeep<Message>): Message;
+/**
+ * Get the value of an option by name
+ * @param args Arguments array (first argument passed to execute)
+ * @param name Name of the argument
+ * @param fallbackValue Fallback value in case this option wasn't passed
+ * @returns Value
+ */
+export declare function findOption<T>(args: Argument[], name: string): T & {} | undefined;
+export declare function findOption<T>(args: Argument[], name: string, fallbackValue: T): T & {};

package/dist/api/Commands/index.d.ts

@@ -0,0 +1,26 @@
+import { Command, Option } from "./types";
+export * from "./commandHelpers";
+export * from "./types";
+export declare let BUILT_IN: Command[];
+export declare const commands: Record<string, Command>;
+/**
+ * Optional message option named "message" you can use in commands.
+ * Used in "tableflip" or "shrug"
+ * @see {@link RequiredMessageOption}
+ */
+export declare let OptionalMessageOption: Option;
+/**
+ * Required message option named "message" you can use in commands.
+ * Used in "me"
+ * @see {@link OptionalMessageOption}
+ */
+export declare let RequiredMessageOption: Option;
+export declare const _init: never;
+export declare const _handleCommand: never;
+/**
+ * Prepare a Command Option for Discord by filling missing fields
+ * @param opt
+ */
+export declare function prepareOption<O extends Option | Command>(opt: O): O;
+export declare function registerCommand<C extends Command>(command: C, plugin: string): void;
+export declare function unregisterCommand(name: string): boolean;

package/dist/api/Commands/types.d.ts

@@ -0,0 +1,74 @@
+import { Channel, Guild } from "discord-types/general";
+import { Promisable } from "type-fest";
+export interface CommandContext {
+    channel: Channel;
+    guild?: Guild;
+}
+export declare enum ApplicationCommandOptionType {
+    SUB_COMMAND = 1,
+    SUB_COMMAND_GROUP = 2,
+    STRING = 3,
+    INTEGER = 4,
+    BOOLEAN = 5,
+    USER = 6,
+    CHANNEL = 7,
+    ROLE = 8,
+    MENTIONABLE = 9,
+    NUMBER = 10,
+    ATTACHMENT = 11
+}
+export declare enum ApplicationCommandInputType {
+    BUILT_IN = 0,
+    BUILT_IN_TEXT = 1,
+    BUILT_IN_INTEGRATION = 2,
+    BOT = 3,
+    PLACEHOLDER = 4
+}
+export interface Option {
+    name: string;
+    displayName?: string;
+    type: ApplicationCommandOptionType;
+    description: string;
+    displayDescription?: string;
+    required?: boolean;
+    options?: Option[];
+    choices?: Array<ChoicesOption>;
+}
+export interface ChoicesOption {
+    label: string;
+    value: string;
+    name: string;
+    displayName?: string;
+}
+export declare enum ApplicationCommandType {
+    CHAT_INPUT = 1,
+    USER = 2,
+    MESSAGE = 3
+}
+export interface CommandReturnValue {
+    content: string;
+    /** TODO: implement */
+    cancel?: boolean;
+}
+export interface Argument {
+    type: ApplicationCommandOptionType;
+    name: string;
+    value: string;
+    focused: undefined;
+    options: Argument[];
+}
+export interface Command {
+    id?: string;
+    applicationId?: string;
+    type?: ApplicationCommandType;
+    inputType?: ApplicationCommandInputType;
+    plugin?: string;
+    isVencordCommand?: boolean;
+    name: string;
+    displayName?: string;
+    description: string;
+    displayDescription?: string;
+    options?: Option[];
+    predicate?(ctx: CommandContext): boolean;
+    execute(args: Argument[], ctx: CommandContext): Promisable<void | CommandReturnValue>;
+}

package/dist/api/ContextMenu.d.ts

@@ -0,0 +1,57 @@
+import type { ReactElement } from "react";
+type ContextMenuPatchCallbackReturn = (() => void) | void;
+/**
+ * @param children The rendered context menu elements
+ * @param args Any arguments passed into making the context menu, like the guild, channel, user or message for example
+ * @returns A callback which is only ran once used to modify the context menu elements (Use to avoid duplicates)
+ */
+export type NavContextMenuPatchCallback = (children: Array<React.ReactElement>, ...args: Array<any>) => ContextMenuPatchCallbackReturn;
+/**
+ * @param navId The navId of the context menu being patched
+ * @param children The rendered context menu elements
+ * @param args Any arguments passed into making the context menu, like the guild, channel, user or message for example
+ * @returns A callback which is only ran once used to modify the context menu elements (Use to avoid duplicates)
+ */
+export type GlobalContextMenuPatchCallback = (navId: string, children: Array<React.ReactElement>, ...args: Array<any>) => ContextMenuPatchCallbackReturn;
+export declare const navPatches: Map<string, Set<NavContextMenuPatchCallback>>;
+export declare const globalPatches: Set<GlobalContextMenuPatchCallback>;
+/**
+ * Add a context menu patch
+ * @param navId The navId(s) for the context menu(s) to patch
+ * @param patch The patch to be applied
+ */
+export declare function addContextMenuPatch(navId: string | Array<string>, patch: NavContextMenuPatchCallback): void;
+/**
+ * Add a global context menu patch that fires the patch for all context menus
+ * @param patch The patch to be applied
+ */
+export declare function addGlobalContextMenuPatch(patch: GlobalContextMenuPatchCallback): void;
+/**
+ * Remove a context menu patch
+ * @param navId The navId(s) for the context menu(s) to remove the patch
+ * @param patch The patch to be removed
+ * @returns Wheter the patch was sucessfully removed from the context menu(s)
+ */
+export declare function removeContextMenuPatch<T extends string | Array<string>>(navId: T, patch: NavContextMenuPatchCallback): T extends string ? boolean : Array<boolean>;
+/**
+ * Remove a global context menu patch
+ * @param patch The patch to be removed
+ * @returns Wheter the patch was sucessfully removed
+ */
+export declare function removeGlobalContextMenuPatch(patch: GlobalContextMenuPatchCallback): boolean;
+/**
+ * A helper function for finding the children array of a group nested inside a context menu based on the id of one of its childs
+ * @param id The id of the child
+ * @param children The context menu children
+ */
+export declare function findGroupChildrenByChildId(id: string, children: Array<React.ReactElement>, _itemsArray?: Array<React.ReactElement>): Array<React.ReactElement> | null;
+interface ContextMenuProps {
+    contextMenuApiArguments?: Array<any>;
+    navId: string;
+    children: Array<ReactElement>;
+    "aria-label": string;
+    onSelect: (() => void) | undefined;
+    onClose: (callback: (...args: Array<any>) => any) => void;
+}
+export declare function _patchContextMenu(props: ContextMenuProps): void;
+export {};

package/dist/api/DataStore/index.d.ts

@@ -0,0 +1,96 @@
+/*!
+ * idb-keyval v6.2.0
+ * Copyright 2016, Jake Archibald
+ * Copyright 2022, Vendicated
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare function promisifyRequest<T = undefined>(request: IDBRequest<T> | IDBTransaction): Promise<T>;
+export declare function createStore(dbName: string, storeName: string): UseStore;
+export type UseStore = <T>(txMode: IDBTransactionMode, callback: (store: IDBObjectStore) => T | PromiseLike<T>) => Promise<T>;
+/**
+ * Get a value by its key.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function get<T = any>(key: IDBValidKey, customStore?: UseStore): Promise<T | undefined>;
+/**
+ * Set a value with a key.
+ *
+ * @param key
+ * @param value
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function set(key: IDBValidKey, value: any, customStore?: UseStore): Promise<void>;
+/**
+ * Set multiple values at once. This is faster than calling set() multiple times.
+ * It's also atomic – if one of the pairs can't be added, none will be added.
+ *
+ * @param entries Array of entries, where each entry is an array of `[key, value]`.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function setMany(entries: [IDBValidKey, any][], customStore?: UseStore): Promise<void>;
+/**
+ * Get multiple values by their keys
+ *
+ * @param keys
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function getMany<T = any>(keys: IDBValidKey[], customStore?: UseStore): Promise<T[]>;
+/**
+ * Update a value. This lets you see the old value and update it as an atomic operation.
+ *
+ * @param key
+ * @param updater A callback that takes the old value and returns a new value.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function update<T = any>(key: IDBValidKey, updater: (oldValue: T | undefined) => T, customStore?: UseStore): Promise<void>;
+/**
+ * Delete a particular key from the store.
+ *
+ * @param key
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function del(key: IDBValidKey, customStore?: UseStore): Promise<void>;
+/**
+ * Delete multiple keys at once.
+ *
+ * @param keys List of keys to delete.
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function delMany(keys: IDBValidKey[], customStore?: UseStore): Promise<void>;
+/**
+ * Clear all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function clear(customStore?: UseStore): Promise<void>;
+/**
+ * Get all keys in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function keys<KeyType extends IDBValidKey>(customStore?: UseStore): Promise<KeyType[]>;
+/**
+ * Get all values in the store.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function values<T = any>(customStore?: UseStore): Promise<T[]>;
+/**
+ * Get all entries in the store. Each entry is an array of `[key, value]`.
+ *
+ * @param customStore Method to get a custom store. Use with caution (see the docs).
+ */
+export declare function entries<KeyType extends IDBValidKey, ValueType = any>(customStore?: UseStore): Promise<[KeyType, ValueType][]>;

package/dist/api/MemberListDecorators.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="react" />
+import { Channel, User } from "discord-types/general/index.js";
+interface DecoratorProps {
+    activities: any[];
+    canUseAvatarDecorations: boolean;
+    channel: Channel;
+    /**
+     * Only for DM members
+     */
+    channelName?: string;
+    /**
+     * Only for server members
+     */
+    currentUser?: User;
+    guildId?: string;
+    isMobile: boolean;
+    isOwner?: boolean;
+    isTyping: boolean;
+    selected: boolean;
+    status: string;
+    user: User;
+    [key: string]: any;
+}
+export type Decorator = (props: DecoratorProps) => JSX.Element | null;
+type OnlyIn = "guilds" | "dms";
+export declare const decorators: Map<string, {
+    decorator: Decorator;
+    onlyIn?: OnlyIn | undefined;
+}>;
+export declare function addDecorator(identifier: string, decorator: Decorator, onlyIn?: OnlyIn): void;
+export declare function removeDecorator(identifier: string): void;
+export declare function __addDecoratorsToList(props: DecoratorProps): (JSX.Element | null)[];
+export {};

package/dist/api/MessageAccessories.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+export type AccessoryCallback = (props: Record<string, any>) => JSX.Element | null | Array<JSX.Element | null>;
+export type Accessory = {
+    callback: AccessoryCallback;
+    position?: number;
+};
+export declare const accessories: Map<String, Accessory>;
+export declare function addAccessory(identifier: string, callback: AccessoryCallback, position?: number): void;
+export declare function removeAccessory(identifier: string): void;
+export declare function _modifyAccessories(elements: JSX.Element[], props: Record<string, any>): JSX.Element[];

package/dist/api/MessageDecorations.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="react" />
+import { Channel, Message } from "discord-types/general/index.js";
+interface DecorationProps {
+    author: {
+        /**
+         * Will be username if the user has no nickname
+         */
+        nick: string;
+        iconRoleId: string;
+        guildMemberAvatar: string;
+        colorRoleName: string;
+        colorString: string;
+    };
+    channel: Channel;
+    compact: boolean;
+    decorations: {
+        /**
+         * Element for the [BOT] tag if there is one
+         */
+        0: JSX.Element | null;
+        /**
+         * Other decorations (including ones added with this api)
+         */
+        1: JSX.Element[];
+    };
+    message: Message;
+    [key: string]: any;
+}
+export type Decoration = (props: DecorationProps) => JSX.Element | null;
+export declare const decorations: Map<string, Decoration>;
+export declare function addDecoration(identifier: string, decoration: Decoration): void;
+export declare function removeDecoration(identifier: string): void;
+export declare function __addDecorationsToMessage(props: DecorationProps): (JSX.Element | null)[];
+export {};

package/dist/api/MessageEvents.d.ts

@@ -0,0 +1,39 @@
+import type { Channel, Message } from "discord-types/general";
+import type { Promisable } from "type-fest";
+export interface Emoji {
+    require_colons: boolean;
+    originalName: string;
+    animated: boolean;
+    guildId: string;
+    name: string;
+    url: string;
+    id: string;
+}
+export interface MessageObject {
+    content: string;
+    validNonShortcutEmojis: Emoji[];
+}
+export interface MessageExtra {
+    stickerIds?: string[];
+}
+export type SendListener = (channelId: string, messageObj: MessageObject, extra: MessageExtra) => Promisable<void | {
+    cancel: boolean;
+}>;
+export type EditListener = (channelId: string, messageId: string, messageObj: MessageObject) => Promisable<void>;
+export declare function _handlePreSend(channelId: string, messageObj: MessageObject, extra: MessageExtra): Promise<boolean>;
+export declare function _handlePreEdit(channelId: string, messageId: string, messageObj: MessageObject): Promise<void>;
+/**
+ * Note: This event fires off before a message is sent, allowing you to edit the message.
+ */
+export declare function addPreSendListener(listener: SendListener): SendListener;
+/**
+ * Note: This event fires off before a message's edit is applied, allowing you to further edit the message.
+ */
+export declare function addPreEditListener(listener: EditListener): EditListener;
+export declare function removePreSendListener(listener: SendListener): boolean;
+export declare function removePreEditListener(listener: EditListener): boolean;
+type ClickListener = (message: Message, channel: Channel, event: MouseEvent) => void;
+export declare function _handleClick(message: Message, channel: Channel, event: MouseEvent): void;
+export declare function addClickListener(listener: ClickListener): ClickListener;
+export declare function removeClickListener(listener: ClickListener): boolean;
+export {};

package/dist/api/MessagePopover.d.ts

@@ -0,0 +1,16 @@
+import { Channel, Message } from "discord-types/general";
+import type { MouseEventHandler } from "react";
+export interface ButtonItem {
+    key?: string;
+    label: string;
+    icon: React.ComponentType<any>;
+    message: Message;
+    channel: Channel;
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    onContextMenu?: MouseEventHandler<HTMLButtonElement>;
+}
+export type getButtonItem = (message: Message) => ButtonItem | null;
+export declare const buttons: Map<string, getButtonItem>;
+export declare function addButton(identifier: string, item: getButtonItem): void;
+export declare function removeButton(identifier: string): void;
+export declare function _buildPopoverElements(msg: Message, makeButton: (item: ButtonItem) => React.ComponentType): import("react").ComponentType<{}>[];

package/dist/api/Notices.d.ts

@@ -0,0 +1,5 @@
+export declare const noticesQueue: any[];
+export declare let currentNotice: any;
+export declare function popNotice(): void;
+export declare function nextNotice(): void;
+export declare function showNotice(message: string, buttonText: string, onOkClick: () => void): void;

package/dist/api/Notifications/NotificationComponent.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import "./styles.css";
+import { NotificationData } from "./Notifications";
+declare const _default: import("react").FunctionComponent<NotificationData & {
+    className?: string | undefined;
+}>;
+export default _default;

package/dist/api/Notifications/Notifications.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+export interface NotificationData {
+    title: string;
+    body: string;
+    /**
+     * Same as body but can be a custom component.
+     * Will be used over body if present.
+     * Not supported on desktop notifications, those will fall back to body */
+    richBody?: ReactNode;
+    /** Small icon. This is for things like profile pictures and should be square */
+    icon?: string;
+    /** Large image. Optimally, this should be around 16x9 but it doesn't matter much. Desktop Notifications might not support this */
+    image?: string;
+    onClick?(): void;
+    onClose?(): void;
+    color?: string;
+    /** Whether this notification should not have a timeout */
+    permanent?: boolean;
+    /** Whether this notification should not be persisted in the Notification Log */
+    noPersist?: boolean;
+    /** Whether this notification should be dismissed when clicked (defaults to true) */
+    dismissOnClick?: boolean;
+}
+export declare function requestPermission(): Promise<boolean>;
+export declare function showNotification(data: NotificationData): Promise<void>;

package/dist/api/Notifications/index.d.ts

@@ -0,0 +1 @@
+export * from "./Notifications";

package/dist/api/Notifications/notificationLog.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { NotificationData } from "./Notifications";
+interface PersistentNotificationData extends Pick<NotificationData, "title" | "body" | "image" | "icon" | "color"> {
+    timestamp: number;
+    id: string;
+}
+export declare function persistNotification(notification: NotificationData): Promise<void>;
+export declare function deleteNotification(timestamp: number): Promise<void>;
+export declare function useLogs(): readonly [PersistentNotificationData[], boolean];
+export declare function NotificationLog({ log, pending }: {
+    log: PersistentNotificationData[];
+    pending: boolean;
+}): JSX.Element;
+export declare function openNotificationLogModal(): void;
+export {};

package/dist/api/ServerList.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare enum ServerListRenderPosition {
+    Above = 0,
+    In = 1
+}
+export declare function addServerListElement(position: ServerListRenderPosition, renderFunction: Function): void;
+export declare function removeServerListElement(position: ServerListRenderPosition, renderFunction: Function): void;
+export declare const renderAll: (position: ServerListRenderPosition) => JSX.Element[];

package/dist/api/SettingsStore.d.ts

@@ -0,0 +1,28 @@
+interface Setting<T> {
+    /**
+     * Get the setting value
+     */
+    getSetting(): T;
+    /**
+     * Update the setting value
+     * @param value The new value
+     */
+    updateSetting(value: T | ((old: T) => T)): Promise<void>;
+    /**
+     * React hook for automatically updating components when the setting is updated
+     */
+    useSetting(): T;
+    settingsStoreApiGroup: string;
+    settingsStoreApiName: string;
+}
+/**
+ * Get the store for a setting
+ * @param group The setting group
+ * @param name The name of the setting
+ */
+export declare function getSettingStore<T = any>(group: string, name: string): Setting<T> | undefined;
+/**
+ * getSettingStore but lazy
+ */
+export declare function getSettingStoreLazy<T = any>(group: string, name: string): Setting<T> | undefined;
+export {};