# frame-djs

> framework de la libreria discord.js

Latest version **1.11.0** (published 2019-09-07) · ISC license · 0 weekly downloads

## Install

```sh
npm install frame-djs
pnpm add frame-djs
yarn add frame-djs
bun add frame-djs
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.11.0 |
| Published | 2019-09-07 |
| First published | 2019-08-08 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 83 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | MegaStar |
| Maintainers | megastar |
| Keywords | discord.js, framework |

## Links

- npm: https://www.npmjs.com/package/frame-djs
- npm.io page: https://npm.io/package/frame-djs

## Dependencies (2)

- [path](https://npm.io/package/path.md) ^0.12.7
- [discord.js](https://npm.io/package/discord.js.md) ^11.5.1

## Alternatives

- [@sveltejs/kit](https://npm.io/package/@sveltejs/kit.md) — 2.2M weekly downloads
- [@atlaskit/theme](https://npm.io/package/@atlaskit/theme.md) — 402.0K weekly downloads
- [@tangle-network/brand](https://npm.io/package/@tangle-network/brand.md) — 10.0K weekly downloads
- [seneca](https://npm.io/package/seneca.md) — 7.4K weekly downloads
- [@bsb/base](https://npm.io/package/@bsb/base.md) — 7.2K weekly downloads

## Recent versions

- 1.11.0 (latest) — 2019-09-07
- 1.10.0 — 2019-08-09
- 1.8.0 — 2019-08-09
- 1.7.0 — 2019-08-09
- 1.5.0 — 2019-08-08

## README

<div align="center">
  <h1>frame-djs</h1>
  <p>Framework para la libreria discord.js</p>
</div>

frame-djs es un nuevo framework de la libreria discord.js la cual te permitira interactuar con discord de forma mas ordenada y sencilla.

## Instalacion:

```shell
npm install frame-djs --save
```

## Changelog:

v1.11.0
* Se agregó dos nuevos metodos al constructor DiscordUtils (split_texto, snowflake).

v1.10.0
* Se mejoró la deteccion del cooldown.

v1.7.0
* Se arregló el constructor PageEmbed.

v1.6.0
* Se arreglaron algunas cosas del README.md (documentacion)


## Demostracion:

https://youtu.be/ogwUxSFHwhc


## Tabla de contenido
*   [Client](#Client)
    *   [`tiene_comando`](#tiene_comando)
    *   [`obtener_comando`](#obtener_comando)
    *   [`ejecutar_comando`](#ejecutar_comando)
    *   [`recargar_comando`](#recargar_comando)
    *   [`tiene_cooldown`](#tiene_cooldown)
*   [Comando](#Comando)
*   [Evento](#Evento)
*   [DiscordUtils](#DiscordUtils)
    *   [`parse_tiempo`](#parse_tiempo)
    *   [`obtener_rol`](#obtener_rol)
    *   [`obtener_miembro`](#obtener_miembro)
    *   [`obtener_emoji`](#obtener_emoji)
    *   [`obtener_canal`](#obtener_canal)
    *   [`permisos`](#permisos)    
    *   [`esObject`](#esObject) 
    *   [`esArray`](#esArray) 
    *   [`esFloat`](#esFloat) 
    *   [`esNum`](#esNum) 
    *   [`unir_array`](#unir_array) 
    *   [`unir_object`](#unir_object) 
    *   [`math`](#math) 
    *   [`verificar_array`](#verificar_array) 
    *   [`split_texto`](#split_texto) 
    *   [`snowflake`](#snowflake) 
*   [PageEmbed](#PageEmbed)
    *   [`paginas`](#paginas)
    *   [`emojis`](#emojis)
    *   [`tiempo`](#tiempo)
    *   [`eliminar`](#eliminar)
    *   [`enviar`](#enviar)


## Client
<a name="Client" />

```js
Client(opciones)
```

Este constructor servira para instanciar(crear) un bot, debes de usarlo como archivo principal para iniciar el bot.

Parametros | Descripcion
--- | ---
`opciones` | Esto es un objeto la cual debera de contener 3 propiedades obligatorias.
`opciones.token` | Aqui deberas de poner el token de tu bot.
`opciones.comandos` | Aqui deberás de poner la ubicacion donde se encuentra la carpeta de tus comandos **(tambien detecta comandos en sub directorios)**, puedes colocar **false** si no tienes ninguno comando.
`opciones.eventos` | Aqui deberás de poner la ubicacion de la carpeta donde estan los eventos, esto es obligatorio.


Por ejemplo:

```js
const Discord = require("frame-djs");

new Discord.Client({
  token: "BOT_TOKEN", //obligatorio
  comandos: "./comandos", //puedes colocar false si no tienes nada.
  eventos: "./eventos" //obligatorio
})
```

### `Nuevos metodos del cliente`

Se creó nuevos metodos para el client **(client seria la instancia del bot, en otras palabras el bot)** las cuales se mostraran a continuacion:

##### tiene_comando
<a name="tiene_comando" />

```js
client.tiene_comando(nombre_comando)
```

Este metodo te permitirá verificar si existe un comando especifico.

En el caso de que tu comando contenga alias, tambien lo verificara.

Parametros | Descripcion
--- | ---
`nombre_comando` | Aqui deberá de ir el nombre del comando a verificar.


###### Retorna

*   `true` — Si se encontró el comando (existe).
*   `false` — Si no se encontró el comando (no existe).

##### obtener_comando
<a name="obtener_comando" />

```js
client.obtener_comando(nombre_comando)
```

Este metodo te permitirá obtener un comando especifico.

En el caso de que tu comando contenga alias, tambien lo verificara.

Si no se coloca ningun valor en el parametro **nombre_comando**, esto regresara un array con los nombres de todos los comandos que actualmente dispones.

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`nombre_comando` | Si | none | Aqui deberá de ir el nombre del comando que se quiere obtener.


###### Retorna

*   `object` — Regresa un objeto con las propiedades del comando obtenido, tales como el nombre y otras cosas mas las cuales tu puedes especificar en el constructor [Comando](#Comando).
*   `array` — Regresa un array con todos los nombres de los comandos que dispones.
*   `false` — Si no se obtuvo nada.

Por ejemplo:

```js
//Obteniendo un comando especifico
let comando = client.obtener_comando("ping")
console.log(comando) //{nombre: "ping", etc...}
```

```js
//Obteniendo todos los comandos
let comandos = client.obtener_comando()
console.log(comandos) //["ping", "etc.."]
```

##### ejecutar_comando
<a name="ejecutar_comando" />

```js
client.ejecutar_comando(nombre_comando, ...args)
```

Este metodo te permitirá ejecutar un comando especifico.

En el caso de que tu comando contenga alias, tambien lo verificara.

Parametros | Descripcion
--- | --- 
`nombre_comando` | Aqui deberá de ir el nombre del comando que se va a ejecutar.
`...args` | Aqui deberán de ir los parametros que quieres pasar al comando, es decir, los argumentos que seran usados al momento de evaluar el codigo del comando, los mas comunes son el **client, message, args** pero puedes colocar los que desees, no hay limites.


Por ejemplo:

```js
//ejemplo 1
client.ejecutar_comando("ping", client, message, args)

//ejemplo 2
client.ejecutar_comando("ping", client, message, args, prefix, etc)
```

###### Retorna

*   `none` — Esto no retorna nada.

###### Recuerda
*   Usa siempre el metodo **tiene_comando** antes de este metodo, asi compruebas si el comando existe.
*   La cantidad de parametros que uses en **...args**, deberás de usarla en la propiedad **ejecutar** del constructor [Comando](#Comando)

##### recargar_comando
<a name="recargar_comando" />

```js
client.recargar_comando(nombre_comando)
```

Este metodo te permitirá recargar un comando especifico.

Si no se coloca ningun valor en el parametro **nombre_comando**, esto recargará todos tus comandos.

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`nombre_comando` | Si | none | Aqui deberá de ir el nombre del comando que se quiere recargar (no alias)


Por ejemplo:

```js
//ejemplo 1
client.recargar_comando("ping") //recarga el codigo del comando ping

//ejemplo 2
client.recargar_comando() //recarga todos los comandos
```

###### Retorna

*   `true` — Si el o los comandos fueron actualizados correctamente.
*   `false` — Si el comando no fue actualizado correctamente.

##### tiene_cooldown
<a name="tiene_cooldown" />

```js
client.tiene_cooldown(nombre_comando, message)
```

Este metodo te permitirá verificar si un usuario está dentro del cooldown del comando, es decir, si puede o no volver a ejecutar dicho comando.

En el caso de que tu comando contenga alias, tambien lo verificara.

Parametros | Descripcion
--- | ---
`nombre_comando` | Aqui deberá de ir el nombre del comando a verificar.
`message` | Aqui deberá de ir el mensaje que se emite en el evento **message**.


###### Retorna

*   `miliseconds` — El tiempo restante que le falta para volver a ejecutar el comando **(regresa el tiempo en milisegundos)**.
*   `false` — Si el usuario no está dentro del cooldown (quiere decir que sí puede volver a ejecutar el comando).

###### Recuerda
*   Usa siempre el metodo **tiene_comando** antes de este metodo, asi compruebas si el comando existe.
*   Esto unicamente funcionará si tienes la propiedad **cooldown** en el comando del constructor [Comando](#Comando)


## Comando
<a name="Comando" />

```js
Comando(opciones)
```

Este constructor servira para crear un comando facilmente, debes de colocarlo en la carpeta donde especificaste la ubicacion de tus comando [Client](#Client).

Parametros | Descripcion
--- | ---
`opciones` | Esto es un objeto la cual debera de contener 2 propiedades obligatorias (tambien puedes crear mas, no hay limites).
`opciones.nombre` | Aqui deberas de poner el nombre del comando.
`opciones.ejecutar` | Aqui deberás de poner una funcion la cual contendrá los parametros que se especificó en el metodo [ejecutar_comando](#ejecutar_comando) (...args). Dentro de esta funcion debes de colocar el codigo que quieres ejecutar.


Ejemplo #1

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "ping",
  ejecutar: (client, message, args) => {
    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`API ms: ${client.ping}`)
    return message.channel.send(embed)
  }
})
```

### `Propiedades especiales`

Se creó propiedades especiales de las cuales puedes hacer uso al momento de crear un comando, son opcionales.

Propiedad | Descripcion
--- | --- 
`alias` | Puedes usar esta propiedad en caso de que quieras que tu comando tenga uno o mas alias, debes de colocar un **array** que contenga los alias del comando, tambien puedes dejarlo vacio en caso de que quieras que tu comando no contengan ninguno: **[]**.
`disponible` | Puedes usar esta propiedad en caso de que quieras deshabilitar un comando **(nadie pueda usarlo)**, debes de colocar **false** para deshabilitarlo o **true** para habilitarlo **(no es necesario usar esta propiedad en caso de que no quieras deshabilitar el comando)**.
`cooldown` | Esto es un objeto, este objeto contiene 2 propiedades.
`cooldown.tiempo` | Aqui deberás de poner el cooldown del comando, es decir, el tiempo de espera para que un usuario pueda volver a ejecutarlo **(debes de poner el tiempo en segundos)**.
`cooldown.permisos` | Esto debe ser un **array** con permisos **(ADMINISTRATOR, MANAGE_ROLES, ETC)**, si el usuario que usó el comando tiene todos estos permisos podrá volver a ejecutar el comando normalmente **(será ignorados por el cooldown y no tendrá que esperar)**. Este array tambien puedes dejarlo vacio **[]**.


Ejemplo #2

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "ping",
  alias: ["ms", "botping"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {
    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`API ms: ${client.ping}`)
    return message.channel.send(embed)
  }
})
```

Ejemplo #3

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "ping",
  alias: ["ms", "botping"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  disponible: false, //Deshabilitamos el comando, en mantenimiento...
  ejecutar: (client, message, args) => {
    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`API ms: ${client.ping}`)
    return message.channel.send(embed)
  }
})
```

###### Recuerda

*   Puedes agregarle mas propiedades, tales como: **descripcion, ejemplo, categoria, etc**, no hay limites.
*   En el caso de que quieras obtener todas las propiedades que le asignaste a un comando, puedes usar el metodo [obtener_comando](#obtener_comando)

Por ejemplo:

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "avatar",
  alias: ["av", "foto"],
  cooldown: {
    tiempo: 5,
    permisos: ["ADMINISTRATOR"]
  },
  descripcion: "Este comando te permite ver el avatar de un usuario.",
  categoria: "Informacion",
  ejemplo: "avatar @usuario",
  ejecutar: (client, message, args) => {
    let usuario = message.mentions.members.first() || message.member
    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setImage(usuario.user.displayAvatarURL)
    return message.channel.send(embed)
  }
})
```


## Evento
<a name="Evento" />

```js
Evento(opciones)
```

Este constructor servira para crear un evento facilmente, debes de colocarlo en la carpeta donde especificaste la ubicacion de tus eventos [Client](#Client).

Parametros | Descripcion
--- | ---
`opciones` | Esto es un objeto la cual debera de contener 2 propiedades obligatorias.
`opciones.nombre` | Aqui deberas de poner el nombre del evento.
`opciones.ejecutar` | Aqui deberás de poner una funcion la cual contendrá como primer parametro el cliente **(client)**, y luego los parametros que originalmente contiene el evento. En todos los eventos es obligatorio siempre usar el cliente **(client)** como primer parametro, pongamos de ejemplo el evento **message**, en su evento esto unicamente recibe el parametro **(message)**, pero en esta version solo deberan de colocar el cliente antes: **(client, message)**, lo mismo si usas otros eventos.


Ejemplo #1

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Evento({
  nombre: "ready",
  ejecutar: (client) => {
    console.log(`Estoy listo en ${client.guilds.size} servidores!`)
  }
})
```

Ejemplo #2

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Evento({
  nombre: "message",
  ejecutar: (client, message) => {
    if(message.author.bot || message.channel.type == "dm") return;
    let prefix = "!!"
    let args = message.content.slice(prefix.length).trim().split(/ +/g);
    let comando = args.shift();

    if(client.tiene_comando(comando)) {
      return client.ejecutar_comando(comando, client, message, args)
    }
  }
})
```


## DiscordUtils
<a name="DiscordUtils" />

```js
DiscordUtils()
```

Este constructor contiene metodos con las cuales podras hacer muchas cosas, son de utilidad.

##### parse_tiempo
<a name="parse_tiempo" />

```js
parse_tiempo(miliseconds, formato, len)
```

Este metodo te permitirá convertir un numero **(debe ser en milisegundos)** a un formato de texto donde se muestre el tiempo en formato de fecha, la fecha detecta **(años, meses, dias, horas, minutos, segundos)** dependiendo del tiempo colocado.


Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`miliseconds` |  |  | Aqui deberá de ir el tiempo a convertir **(debe ser en milisegundos)**.
`formato` |  |  | Aqui deberá de ir un texto que se usará como identificador para colocar la fecha, la palabra reservada para colocar la fecha es **{{tiempo}}**, puedes colocarlo en el lugar que quieras.
`len` | Si | "es" | Esto indica el idioma con el que la fecha sera puesta, por default está en "es" **(español)**, si quieres que la fecha salga en ingles, coloca **"en"**, 


###### Retorna

*   `string` — Regresa el texto del parametro **formato** con la fecha.

Por ejemplo:

```js
//En español
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()
let tiempo = utils.parse_tiempo(65000, "Debes de esperar {{tiempo}} para usar este comando.")
```
![En español](https://cdn.discordapp.com/attachments/607390366689263618/609095009383350306/unknown.png)

```js
//En ingles
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()
let tiempo = utils.parse_tiempo(65000, "You must wait {{tiempo}} to use this command.", "en")
```
![En ingles](https://cdn.discordapp.com/attachments/607390366689263618/609095313487036416/unknown.png)

###### Recuerda

*   Este metodo puedes usarlo si tienes activado la propiedad del **cooldown** y quieras obtener el tiempo que le falta a un usuario para volver a ejecutar un comando, recuerda que el metodo [tiene_cooldown](#tiene_cooldown) regresa el tiempo en milisegundos si un usuario aun no puede volver a ejecutar un comando, ese tiempo puedes pasarlo al parametro **miliseconds**.


Por ejemplo: 

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Evento({
  nombre: "message",
  ejecutar: (client, message) => {
    if(message.author.bot || message.channel.type == "dm") return;
    let prefix = "!!"
    let args = message.content.slice(prefix.length).trim().split(/ +/g);
    let comando = args.shift();

    if(client.tiene_comando(comando)) {
      let coold = client.tiene_cooldown(comando, message)
      if(!coold) { //Si puede volver a ejecutar el comando
        return client.ejecutar_comando(comando, client, message, args)
      }
      //En el caso de que aun tenga que esperar, coold ahora contiene el tiempo de espera en milisegundos
      let utils = new Discord.DiscordUtils()
      return message.channel.send(utils.parse_tiempo(coold, "Necesitas esperar {{tiempo}} para volver a ejecutar el comando"))
    }
  }
})
```

##### obtener_rol
<a name="obtener_rol" />

```js
obtener_rol(message, nombre_id)
```

Este metodo te permitirá obtener un rol ya sea mediante una mencion, nombre o ID.

En el caso de que quieras obtener un rol unicamente mediante una mencion, solo usa el parametro **message**.

En el caso de que quieras obtener un rol mediante una mencion, nombre o ID, usa el parametro **nombre_id**

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`message` |  |  | Aqui deberá de ir el **message** que se emite en el evento message, se verificará si el mensaje contiene una mencion, esto regresará al primer rol mencionado **(si se encuentra)**.
`nombre_id` | Si | none | Aqui deberá de ir el nombre o ID del rol, esto se evaluará unicamente si no se mencionó a ningun usuario en el mensaje.


###### Retorna

*   [Role](https://discord.js.org/#/docs/main/stable/class/Role) — Regresa el rol obtenido.
*   `null` — Regresa null en caso de que no se encontró ningun rol.

Por ejemplo:

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "roleinfo",
  alias: ["role"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {
    if(!args[0]) return message.channel.send("Menciona un rol o coloca su nombre o ID.")

    let utils = new Discord.DiscordUtils()
    let rol = utils.obtener_rol(message, args.join(" "))
    if(!rol) return message.channel.send("No se encontró ningun rol")

    let embed = new Discord.RichEmbed()
    embed.setColor(rol.color)
    embed.setDescription(`Nombre: ${rol.name}\nID: ${rol.id}`)
    return message.channel.send(embed)
  }
})
```

##### obtener_miembro
<a name="obtener_miembro" />

```js
obtener_miembro(message, nombre_id, global)
```

Este metodo te permitirá obtener un miembro **(GuildMember)** ya sea mediante una mencion, nombre o ID.

En el caso de que quieras obtener un miembro unicamente mediante una mencion, solo usa el parametro **message**.

En el caso de que quieras obtener un miembro mediante una mencion, nombre o ID, usa el parametro **nombre_id**.

En el caso de que quieras obtener un usuario **(User)** ya sea mediante **nombre o ID** del cache del cliente, es decir, de la coleccion del **client.users**, usa el parametro **global**

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`message` |  |  | Aqui deberá de ir el **message** que se emite en el evento message, se verificará si el mensaje contiene una mencion, esto regresará al primer miembro mencionado **(si se encuentra)**.
`nombre_id` | Si | none | Aqui deberá de ir el nombre o ID del miembro, esto se evaluará unicamente si no se mencionó a ningun miembro en el mensaje.
`global` | Si | false | Si quieres obtener a un User del cache del cliente **(client.users)**, puedes colocar **true**


###### Retorna

*   [GuildMember](https://discord.js.org/#/docs/main/stable/class/GuildMember) — Regresa el miembro (guildMember) obtenido.
*   [User](https://discord.js.org/#/docs/main/stable/class/User) — Regresa el Usuario (User) si el parametro **global** está en **true**.
*   `null` — Regresa null en caso de que no se encontró ningun miembro/usuario.

Por ejemplo:

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "userinfo",
  alias: ["user"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {
    if(!args[0]) return message.channel.send("Menciona un miembro o coloca su nombre o ID.")

    let utils = new Discord.DiscordUtils()
    let usuario = utils.obtener_miembro(message, args.join(" "))
    if(!usuario) return message.channel.send("No se encontró ningun usuario.")

    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`Nombre: ${usuario.user.username}\nID: ${usuario.id}`)
    embed.setThumbnail(usuario.user.displayAVatarURL)
    return message.channel.send(embed)
  }
})
```

##### obtener_emoji
<a name="obtener_emoji" />

```js
obtener_emoji(message, nombre_id, global)
```

Este metodo te permitirá obtener un emoji ya sea mediante un nombre o ID.

En el caso de que quieras obtener un emoji del mismo servidor donde se ejecutó el comando, solo usa el parametro **message** y **nombre_id**.

En el caso de que quieras obtener un emoji especifico ya sea mediante **nombre o ID** de la coleccion de todos los emojis a los que el cliente tiene acceso **(client.emojis)**, usa el parametro **global**

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`message` |  |  | Aqui deberá de ir el **message** que se emite en el evento message.
`nombre_id` |  |  | Aqui deberá de ir el nombre o ID del emoji.
`global` | Si | false | Si quieres obtener un emoji de la coleccion **(client.emojis)**, puedes colocar **true**


###### Retorna

*   [Emoji](https://discord.js.org/#/docs/main/stable/class/Emoji) — Regresa el emoji obtenido.
*   `null` — Regresa null en caso de que no se encontró ningun emoji.

Por ejemplo:

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "emoji",
  alias: ["em"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {
    if(!args[0]) return message.channel.send("Coloca el nombre o ID de un emoji.")

    let utils = new Discord.DiscordUtils()
    let emoji = utils.obtener_emoji(message, args.join(" "), true)
    if(!emoji) return message.channel.send("No se encontró ningun emoji.")

    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`Nombre: ${emoji.name}\nID: ${emoji.id}`)
    embed.setThumbnail(emoji.url)
    return message.channel.send(embed)
  }
})
```

##### obtener_canal
<a name="obtener_canal" />

```js
obtener_canal(message, nombre_id, global)
```

Este metodo te permitirá obtener un canal ya sea mediante una mencion, nombre o ID.

En el caso de que quieras obtener un canal unicamente mediante una mencion, solo usa el parametro **message**.

En el caso de que quieras obtener un canal mediante una mencion, nombre o ID, usa el parametro **nombre_id**.

En el caso de que quieras obtener un canal de todos los canales a los que el cliente tiene acceso **(client.channels)**, usa el parametro **global**

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`message` |  |  | Aqui deberá de ir el **message** que se emite en el evento message, se verificará si el mensaje contiene una mencion, esto regresará al primer canal mencionado **(si se encuentra)**.
`nombre_id` | Si | none | Aqui deberá de ir el nombre o ID del canal, esto se evaluará unicamente si no se mencionó a ningun miembro en el mensaje.
`global` | Si | false | Si quieres obtener un canal de la coleccion **(client.channels)**, puedes colocar **true**


###### Retorna

*   [TextChannel](https://discord.js.org/#/docs/main/stable/class/TextChannel) — Regresa el canal obtenido.
*   `null` — Regresa null en caso de que no se encontró ningun canal.

Por ejemplo:

```js
//Ejemplo basico
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "canalinfo",
  alias: ["canal"],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {
    if(!args[0]) return message.channel.send("Menciona un canal o coloca su nombre o ID.")

    let utils = new Discord.DiscordUtils()
    let canal = utils.obtener_canal(message, args.join(" "), true)
    if(!canal) return message.channel.send("No se encontró ningun canal.")

    let embed = new Discord.RichEmbed()
    embed.setColor("RANDOM")
    embed.setDescription(`Nombre: ${canal.name}\nID: ${canal.id}`)
    return message.channel.send(embed)
  }
})
```

##### permisos
<a name="permisos" />

```js
permisos(permisos, miembro, len)
```

Este metodo te permitirá verificar que permisos le falta a un miembro tomando como referencia un array de permisos a verificar.

Esto regresará un array con los permisos faltantes, los nombres de los permisos estaran en español (puedes cambiarlo en el parametro **len**)

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`permisos` |  |  | Aqui deberá de ir un array que contenga los permisos que se verificara.
`miembro` |  |  | Aqui deberá de ir un miembro **(GuildMember)**, en el caso de que quieras comprobar los permisos del bot, puedes usar **message.guild.me**
`len` | Si | "es" | Esto indica el idioma con el que se regresará el nombre de los permisos faltantes, por default estará en **"es"** (español), si quieres obtenerlos en ingles, coloca **"en"** 


###### Retorna

*   `array` — Regresa un array con el nombre de los permisos faltantes.

Por ejemplo:

![permisos](https://cdn.discordapp.com/attachments/607390366689263618/609112954704494602/unknown.png)
```js
//En español
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()
let perms = ["MANAGE_ROLES", "KICK_MEMBERS", "MANAGE_CHANNELS"]
if(!message.guild.me.hasPermission(perms)) {
  let faltantes = utils.permisos(perms, message.guild.me)
  return message.channel.send(`Me faltan tener estos permisos:\n\n${faltantes.join("\n")}`)
}
```
![En español](https://cdn.discordapp.com/attachments/607390366689263618/609113471199739914/unknown.png)

```js
//En ingles
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()
let perms = ["MANAGE_ROLES", "KICK_MEMBERS", "MANAGE_CHANNELS"]
if(!message.guild.me.hasPermission(perms)) {
  let faltantes = utils.permisos(perms, message.guild.me, "en")
  return message.channel.send(`I'm missing having these permissions:\n\n${faltantes.join("\n")}`)
}
```
![En ingles](https://cdn.discordapp.com/attachments/607390366689263618/609113649151475714/unknown.png)

##### esObject
<a name="esObject" />

```js
esObject(elemento)
```

Este metodo te permitirá verificar si un elemento es un objeto.

Parametros | Descripcion
--- | ---
`elemento` | Aqui deberá de ir el elemento que se verificara.


###### Retorna

*   `true` — Si es un objeto (object)
*   `false` — Si no es un objeto (object)

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let elem = "frase del dia"
let elem2 = {
  type: 1
}

console.log(utils.esObject(elem)) //retorna false
console.log(utils.esObject([])) //retorna false
console.log(utils.esObject(["1", {pedro: "12"}])) //retorna false
console.log(utils.esObject(5)) //retorna false
console.log(utils.esObject({type: 5})) //retorna true
console.log(utils.esObject(elem2)) //retorna true
```

##### esArray
<a name="esArray" />

```js
esArray(elemento)
```

Este metodo te permitirá verificar si un elemento es un array.

Parametros | Descripcion
--- | ---
`elemento` | Aqui deberá de ir el elemento que se verificara.


###### Retorna

*   `true` — Si es un array
*   `false` — Si no es un array

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let elem = "frase del dia"
let elem2 = ["5", "5", ["asd2"]]

console.log(utils.esArray(elem)) //retorna false
console.log(utils.esArray([])) //retorna true
console.log(utils.esArray(5)) //retorna false
console.log(utils.esArray({type: 5})) //retorna false
console.log(utils.esArray(elem2)) //retorna true
```

##### esFloat
<a name="esFloat" />

```js
esFloat(elemento)
```

Este metodo te permitirá verificar si un elemento es un flotante (numero).

Parametros | Descripcion
--- | ---
`elemento` | Aqui deberá de ir el elemento que se verificara.


###### Retorna

*   `true` — Si es un flotante
*   `false` — Si no es un flotante

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let elem = "frase del dia"
let elem2 = "12.6"
let elem3 = 1.6

console.log(utils.esFloat(elem)) //retorna false
console.log(utils.esFloat([])) //retorna false
console.log(utils.esFloat(5)) //retorna false
console.log(utils.esFloat({type: 5})) //retorna false
console.log(utils.esFloat(elem2)) //retorna true
console.log(utils.esFloat(elem3)) //retorna true
```

##### esNum
<a name="esNum" />

```js
esNum(elemento)
```

Este metodo te permitirá verificar si un elemento es un numero.

Parametros | Descripcion
--- | ---
`elemento` | Aqui deberá de ir el elemento que se verificara.


###### Retorna

*   `true` — Si es un numero
*   `false` — Si no es un numero

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let elem = "frase del dia"
let elem2 = "12.6"
let elem3 = 1.6

console.log(utils.esNum(elem)) //retorna false
console.log(utils.esNum([])) //retorna false
console.log(utils.esNum(5)) //retorna true
console.log(utils.esNum({type: 5})) //retorna false
console.log(utils.esNum(elem2)) //retorna true
console.log(utils.esNum(elem3)) //retorna true
console.log(utils.esNum(true)) //retorna false
console.log(utils.esNum(false)) //retorna false
```

##### unir_array
<a name="unir_array" />

```js
unir_array(primero, ...args)
```

Este metodo te permitire unir los elementos de dos o mas arrays tomando como punto principal el primer array del parametro **primero**, esto te regresa un nuevo array sin modificar ninguno de ellos.


Parametros | Descripcion
--- | ---
`primero` | Aqui deberá de ir el array donde se uniran los elementos de los demas arrays.
`...args` | Aqui deberá de ir los parametros(arrays) que quieres unir al array del parametro **primero**, no hay limite.


###### Retorna

*   `array` — Regresa un nuevo array con todos los elementos.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let array1 = ["mario", "pedro", "juan"]
let array2 = [1, 2, 3, 4]
let array3 = [[2, 4], {type: 1}]

let nuevo_array = utils.unir_array(array, array2, array3)
console.log(nuevo_array) // ["mario", "pedro", "juan", 1, 2, 3, 4, [2, 4], {type: 1}]
console.log(array1) // ["mario", "pedro", "juan"]
console.log(array2) // [1, 2, 3, 4]
console.log(array3) // [[2, 4], {type: 1}]
```

##### unir_object
<a name="unir_object" />

```js
unir_object(primero, ...args)
```

Este metodo te permitire unir las propiedades de dos o mas objetos tomando como punto principal el primer objeto del parametro **primero**, esto te regresa un nuevo objeto sin modificar ninguno de ellos.


Parametros | Descripcion
--- | ---
`primero` | Aqui deberá de ir el objeto donde se uniran las propiedades de los demas objetos.
`...args` | Aqui deberá de ir los parametros(objetos) que quieres unir al objeto del parametro **primero**, no hay limite.


###### Retorna

*   `object` — Regresa un nuevo objeto con todas las propiedades.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let objeto1 = {nombre: "MegaStar"}
let objeto2 = {juego: "paladins", nivel: 15}
let objeto3 = {items: {status: true}}

let nuevo_objeto = utils.unir_object(objeto1, objeto2, objeto3)
console.log(nuevo_objeto)
/*
{
  "nombre": "MegaStar",
  "juego": "paladins",
  "nivel": 15,
  "items": {
    "status": true
  }
}
*/

console.log(objeto1) // {"nombre": "MegaStar"}
console.log(objeto2) // {"juego": "paladins", "nivel": 15}
console.log(objeto3) // {"items": {"status": true}}
```

##### math
<a name="math" />

```js
math(simbolo, ...args)
```

Este metodo te permite hacer una operacion matematica rapidamente.

Parametros | Descripcion
--- | ---
`simbolo` | Aqui deberá de ir el simbolo de la operacion que quieres hacer, el simbolo "*" es para multiplicar, el simbolo "+" para sumar, el simbolo "-" para restar y el simbolo "/" para dividir.
`...args` | Aqui deberá de ir los parametros(numeros) que quieres usar en la operacion que especificaste en el parametro **simbolo**, en el caso de la division, solo se tomara 2 numeros, en el caso de la **suma, restar y multiplicacion** puedes usar los numeros que quieras, no hay limite.


###### Retorna

*   `numero` — Regresa el resultado de la operacion empleada.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let suma = utils.math("+", 1, 10, "15", 2)
console.log(suma) //retorna 28

let resta = utils.math("+", 50, 4, "2", 9, 3)
console.log(resta) //retorna 32

let multiplicacion = utils.math("*", 5, 34, "13")
console.log(multiplicacion) //retorna 2210

let division = utils.math("/", 124, 12)
console.log(division) //retorna 10,3333333
```

##### verificar_array
<a name="verificar_array" />

```js
verificar_array(elemento)
```

Este metodo te permitirá verificar si algun elemento se repite en un array.

Parametros | Descripcion
--- | ---
`elemento` | Aqui deberá de ir un array, se verificará si algun elemento de este array se repite.


###### Retorna

*   `true` — Si un elemento del array se repite.
*   `false` — Si ningun elemento del array se repite.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let array1 = ["🍇", "🍎", "megastar", "🍎"]
let array2 = ["🍇", "🍎", "🍌", "🍏"]
let array3 = ["mario", "juan", "pedro", "moder"]

console.log(utils.verificar_array(array1)) //retorna true
console.log(utils.verificar_array(array2)) //retorna false
console.log(utils.verificar_array(array3)) //retorna false
```

##### split_texto
<a name="split_texto" />

```js
split_texto(texto, longitud, caracter)
```

Este metodo te permitirá dividir una cadena de texto en una lontigud especifica, el texto sera dividido en la longitud que especificaste y las partes divididas seran almacenados en un array. 

Esto puedes usarlo para mandar un texto con mas de **2000** lineas en un **mensaje/embed**.

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`texto` |  |  | Aqui deberá de ir el texto que sera dividido.
`longitud` | Si | 1024 | Aqui deberá de ir la longitud(numero) maxima de caracteres por mensaje **(por default es 1024)**.
`caracter` | Si | \n | Aqui debera de ir el simbolo que se usara como identificador para separar la cadena de texto del parametro **texto**, por default es **\n**.


###### Retorna

*   `Array` — Regresa un array ordenado con el texto dividio.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let lyric = `This was all you, none of it me
You put your hands on, on my body and told me
Mmm
You told me you were ready
For the big one, for the big jump
I'd be your last love everlasting you and me
Mmm
That was what you told me

I'm giving you up
I've forgiven it all
You set me free

Send my love to your new lover
Treat her better
We've gotta let go of all of our ghosts
We both know we ain't kids no more
Send my love to your new lover
Treat her better
We've gotta let go of all of our ghosts
We both know we ain't kids no more

I was too strong, you were trembling
You couldn't handle the hot heat rising (rising)
Mmm
Baby, I'm still rising
I was running, you were walking
You couldn't keep up, you were falling down (down)
Mmm
There's only one way down

I'm giving you up
I've forgiven it all
You set me free, oh

Send my love to your new lover
Treat her better
We gotta let go of all of our ghosts
We both know we ain't kids no more
Send my love to your new lover
Treat her better
We've gotta let go of all of our ghosts
We both know we ain't kids no more...`

let mensajes = utils.split_texto(lyric, 500)
console.log(mensajes)

/*
En el caso de que quieras mandar un mensaje que contenga mas de 2000 caracteres en un embed (setDescription solo puede contener 2024 caracteres)
puedes hacerlo de la siguiente manera:

let mensajes = utils.split_texto(lyric, 2000)

for(var texto of mensajes) {
  let embed = new Discord.RichEmbed()
  embed.setColor("GREEN")
  embed.setDescription(texto)
  message.channel.send(embed)
}
*/
```
![split_imagen](https://cdn.discordapp.com/attachments/607386239074828308/619683052544720896/unknown.png)

##### snowflake
<a name="snowflake" />

```js
snowflake(id)
```

Este metodo te permitirá obtener la fecha de creacion de una ID (snowflake). 

Parametros | Descripcion
--- | ---
`id` | Aqui deberá de ir el ID a convertir.


###### Retorna

*   `Object` — Regresa un objeto con 6 propiedades: **(año, mes, dia, hora, minuto, segundo)** y el valor de estas propiedades contienen la fecha en formato de numero.

Por ejemplo:

```js
const Discord = require("frame-djs");
let utils = new Discord.DiscordUtils()

let fecha = utils.snowflake("292092693377712128")
console.log(fecha)
/*

{
  "año": "2017",
  "mes": "03",
  "dia": "17",
  "hora": "00",
  "minuto": "32",
  "segundo": "04"
}

*/

console.log(`${fecha.dia}/${fecha.mes}/${fecha.año} - ${fecha.hora}:${fecha.minuto}:${fecha.segundo}`)
// 17/03/2017 - 00:32:04
```

## PageEmbed
<a name="PageEmbed" />

```js
PageEmbed(message, modo)
```

Este constructor contiene metodos con las cuales podras hacer paginas con embeds usando emojis ya sean del mismo discord o personalizados.

Parametros | Opcional | Default | Descripcion
--- | --- | --- | ---
`message` |  |  | Aqui deberá de ir el **message** que se emite en el evento message.
`modo` | Si | "seleccion" | Aqui deberas de poner el modo de la pagina, el modo "**seleccion**" sirve para hacer que se muestre un embed especifico con un emoji correspondiente, el modo "**pagina**" sirve para hacer que se recorran varios embeds como si fueran una especie de libro (por default esto estarà en el modo "**seleccion**")


Por ejemplo:

```js
//Estilo "seleccion"
let pagina_estilo1 = new Discord.PageEmbed(message)
```

```js
//Estilo "pagina"
let pagina_estilo2 = new Discord.PageEmbed(message, "pagina")
```

##### paginas
<a name="paginas" />

```js
paginas(objeto)
```

Si el modo del constructor PageEmbed es "**seleccion**", el valor del parametro **objeto** debe ser un objeto, de lo contrario si el modo es "**pagina**", debe ser un array.


Parametros | Descripcion
--- | --- 
`objeto` | Como se menciono anteriormente, en el caso de que el modo sea "**seleccion**", debes de colocar un objeto que contenga como **clave(key)** el emoji y como **valor(value)** el embed que se mostrará cuando se reaccione a ese emoji, el emoji puede ser del mismo discord o una ID de un emoji personalizado, el numero maximo de emojis/embeds es de **20**. Si el modo es "**pagina**", debes de colocar un array la cual contenga los embeds que se mostraran (no hay limite de embeds).


Por ejemplo:

```js
//En el modo "seleccion"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message)
seleccion_p.paginas({
  "🍇": embed1, //El embed lo puedes construir con el constructor RichEmbed()
  "🍎": embed2, //El embed lo puedes construir con el constructor RichEmbed()
  "600778889463201834": embed3 //El embed lo puedes construir con el constructor RichEmbed()
})
```

```js
//En el modo "pagina"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message, "pagina")
seleccion_p.paginas([embed1, embed2, embed3, embed4]) //Los embeds puedes construirlo con el constructor RichEmbed()
```

##### emojis
<a name="emojis" />

```js
emojis(array)
```

Este metodo unicamente funcionará si el modo del constructor PageEmbed es "**pagina**".


Parametros | Descripcion
--- | --- 
`array` | Aqui deberá de ir un array con 3 emojis, el primero emoji se usará para retroceder una pagina, el segundo emoji se usará para eliminar las paginas(cancelar) y el tercer emoji se usará para avanzar de pagina, debes de colocar obligatoriamente 3 emojis, los emojis pueden ser del mismo Discord o una ID de un emoji personalizado.


Por ejemplo:

```js
//En el modo "pagina"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message, "pagina")
seleccion_p.paginas([embed1, embed2, embed3, embed4]) //Los embeds puedes construirlo con el constructor RichEmbed()
seleccion_p.emojis(["⬅", "607390384074653716", "➡"]) //Aqui tambien estoy usando una ID de un emoji.
//⬅ para retroceder de pagina
// 607390384074653716 para eliminar las paginas(cancelar)
//➡ para avanzar de pagina
```

##### tiempo
<a name="tiempo" />

```js
tiempo(miliseconds)
```

Este metodo te permite ponerle un tiempo especifico a tus paginas que hiciste con los embeds, es decir, pasando el tiempo que especificaste, ya no se podra cambiar de pagina, practicamente esto le pone una duracion (por default el tiempo de duracion es de 60000 = 1 minuto)


Parametros | Descripcion
--- | --- 
`miliseconds` | Aqui deberá de ir el tiempo de duracion que tendra tu pagina **(el tiempo debe ser en milisegundos)**


Por ejemplo:

```js
//En el modo "seleccion"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message)
seleccion_p.paginas({
  "🍇": embed1,
  "🍎": embed2,
  "600778889463201834": embed3
})
seleccion_p.tiempo(30000) //Solo durará 30 segundos

```

```js
//En el modo "pagina"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message, "pagina")
seleccion_p.paginas([embed1, embed2, embed3, embed4])
seleccion_p.emojis(["⬅", "607390384074653716", "➡"])
seleccion_p.tiempo(30000) //Solo durará 30 segundos
```

##### eliminar
<a name="eliminar" />

```js
eliminar(boolean)
```

Este metodo te permite eliminar el mensaje que contiene las paginas una vez que la duracion haya terminado, por default esto está en false **(no se eliminara)**

Parametros | Descripcion
--- | --- 
`boolean` | Puedes colocar **true** si quieres que el mensaje que contiene las paginas se eliminen una vez que el tiempo de duracion haya terminado, de lo contrario **false** (no es necesario usar este metodo si no quieres eliminar el mensaje) 


Por ejemplo:

```js
//En el modo "seleccion"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message)
seleccion_p.paginas({
  "🍇": embed1,
  "🍎": embed2,
  "600778889463201834": embed3
})
seleccion_p.tiempo(30000)
seleccion_p.eliminar(true) //El mensaje se eliminará cuando el tiempo haya terminado

```

```js
//En el modo "pagina"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message, "pagina")
seleccion_p.paginas([embed1, embed2, embed3, embed4])
seleccion_p.emojis(["⬅", "607390384074653716", "➡"])
seleccion_p.tiempo(30000)
seleccion_p.eliminar(true) //El mensaje se eliminará cuando el tiempo haya terminado
```

##### enviar
<a name="enviar" />

```js
enviar()
```

Este metodo servira para enviar el mensaje con las paginas, recuerda que siempre debe ir al final de todos los metodos nombrados anteriormente.


Por ejemplo:

```js
//En el modo "seleccion"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message)
seleccion_p.paginas({
  "🍇": embed1,
  "🍎": embed2,
  "600778889463201834": embed3
})
seleccion_p.tiempo(30000)
seleccion_p.eliminar(true)
return seleccion_p.enviar()

```

```js
//En el modo "pagina"
const Discord = require("frame-djs");

let seleccion_p = new Discord.PageEmbed(message, "pagina")
seleccion_p.paginas([embed1, embed2, embed3, embed4])
seleccion_p.emojis(["⬅", "607390384074653716", "➡"])
seleccion_p.tiempo(30000)
seleccion_p.eliminar(true)
return seleccion_p.enviar()
```


Ejemplo usando el metodo "seleccion"

```js
const Discord = require("frame-djs");

module.exports = new Discord.Comando({
  nombre: "pagina1",
  alias: [],
  cooldown: {
    tiempo: 10,
    permisos: ["ADMINISTRATOR"]
  },
  ejecutar: (client, message, args) => {

    let p_1 = new Discord.RichEmbed()
    p_1.setDescription("Esta es la pagina 1")
    p_1.setColor("GREEN")
    p_1.setFooter("Hola mundo")

    let p_2 = new Discord.RichEmbed()
    p_2.setDescription("Esta es la pagina 2")
    p_2.setColor("BLUE")
    p_2.setFooter("MegaStar")
  
    let p_3 = new Discord.RichEmbed()
    p_3.setDescription("Esta es la pagina 3")
    p_3.setColor("RED")
    p_3.setFooter("usa frame-djs")

    let seleccion_p = new Discord.PageEmbed(message)
    seleccion_p.paginas({
      "🍇": p_1,
      "🍎": p_2,
      "🍌": p_3
    })
    seleccion_p.tiempo(30000)
    seleccion_p.eliminar(true)
    return seleccion_p.enviar()    
  }

})
```
![Seleccion](https://cdn.discordapp.com/attachments/607390366689263618/609159530122838016/unknown.png)

---
_Source: https://npm.io/package/frame-djs · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._