Saltearse al contenido

Transformers

¿Qué es un transformer?

Basicamente, un transformer es una función que toma un objeto y lo transforma en otro valor. En Seyfert, los transformers son usados para transformar los datos que vienen de discord en valores cualesquiera que necesites.

¿Cómo se usan?

Vamos a ver un ejemplo de un transformer.

import { 
const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers } from 'seyfert';

const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers.
function User(client: UsingClient, data: APIUser): UserStructure
User = (
client: UsingClient
client, 
data: APIUser
data) => {
    return {
        
MyUser.username: string
username: 
data: APIUser
data.
APIUser.username: string
The user's username, not unique across the platform
username,
        
MyUser.esAdmin: boolean
esAdmin: 
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants.
Math.
Math.random(): number
Returns a pseudorandom number between 0 and 1.
random() > 0.5,
        
MyUser.raw(): Promise<APIUser>
raw() {
            return 
client: UsingClient
client.
BaseClient.users: UsersShorter
users.
UsersShorter.raw(userId: string, force?: boolean): Promise<APIUser>
raw(
data: APIUser
data.
APIUser.id: string
The user's id
id);
        },
    };
};

/*
Ya llegado a este punto,
deberias tener un `declare module "seyfert"` en tu proyecto,
si no, añadelo.
*/
declare module "seyfert" {
// Declarando el tipo de esta manera,
// se reflejará en el tipado de todo el proyecto.
    interface 
interface CustomStructures
CustomStructures {
        
CustomStructures.User: MyUser
User: 
interface MyUser
MyUser;
// Puedes añadir tantos transformers como quieras, con cualquier tipo
    }
}

Dejate llevar por el autocompletado de tu editor y descubre todas las posibilidades que tienes.

import { 
const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers } from 'seyfert';

const Transformers: {
    AnonymousGuild(client: UsingClient, data: APIPartialGuild): AnonymousGuildStructure;
    ... 29 more ...;
    Entitlement(client: UsingClient, data: APIEntitlement): EntitlementStructure;
}
Transformers.Guil dMemberGuild
GuildBan
GuildEmoji
GuildMember
GuildRole

¿Cómo puedo usarlos?

Por ejemplo, arriba hemos definido un transformer para el usuario, ahora vamos a ver cómo podemos usarlo.

import { type 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext, 
class Command
Command, 
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare } from 'seyfert';

@
function Declare(declare: CommandDeclareOptions): <T extends {
    new (...args: any[]): object;
}>(target: T) => {
    new (...args: any[]): {
        name: string;
        nsfw: boolean | undefined;
        props: ExtraProps | undefined;
        contexts: InteractionContextType[];
        integrationTypes: ApplicationIntegrationType[];
        defaultMemberPermissions: bigint | undefined;
        botPermissions: bigint | undefined;
        description: string;
        type: ApplicationCommandType;
        guildId?: string[];
        ignore?: IgnoreCommand;
        aliases?: string[];
        handler?: EntryPointCommandHandlerType;
    };
} & T
Declare({
    
name: string
name: 'ping',
    
description: string
description: 'Ping!',
})
class 
class Ping
Ping extends 
class Command
Command {
    async 
Ping.run(ctx: CommandContext): Promise<void>
run(
ctx: CommandContext<{}, never>
ctx: 
class CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
interface CommandContext<T extends OptionsRecord = {}, M extends keyof RegisteredMiddlewares = never>
CommandContext) {
        const 
const result: APIUser
result = await 
ctx: CommandContext<{}, never>
ctx.
CommandContext<{}, never>.author: MyUser
author. 
MyUser.raw(): Promise<APIUser>
raw();esAdmin
raw
username
        
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(
const result: APIUser
result.
APIUser.id: string
The user's id
id, 
const result: APIUser
result.
APIUser.username: string
The user's username, not unique across the platform
username);
    }
}

A seyfert transformer