@hasna/skills 0.1.22 → 0.1.23

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/hono.mdx

@@ -1,47 +0,0 @@
----
-title: Build an HTTP server using Hono and Bun
-sidebarTitle: Hono with Bun
-mode: center
----
-
-[Hono](https://github.com/honojs/hono) is a lightweight ultrafast web framework designed for the edge.
-
-```ts server.ts icon="/icons/typescript.svg"
-import { Hono } from "hono";
-const app = new Hono();
-
-app.get("/", c => c.text("Hono!"));
-
-export default app;
-```
-
----
-
-Use `create-hono` to get started with one of Hono's project templates. Select `bun` when prompted for a template.
-
-```sh terminal icon="terminal"
-bun create hono myapp
-```
-
-```txt
-✔ Which template do you want to use? › bun
-cloned honojs/starter#main to /path/to/myapp
-✔ Copied project files
-```
-
-```sh terminal icon="terminal"
-cd myapp
-bun install
-```
-
----
-
-Then start the dev server and visit [localhost:3000](http://localhost:3000).
-
-```sh terminal icon="terminal"
-bun run dev
-```
-
----
-
-Refer to Hono's guide on [getting started with Bun](https://hono.dev/getting-started/bun) for more information.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/mongoose.mdx

@@ -1,92 +0,0 @@
----
-title: Read and write data to MongoDB using Mongoose and Bun
-sidebarTitle: Mongoose with Bun
-mode: center
----
-
-MongoDB and Mongoose work out of the box with Bun. This guide assumes you've already installed MongoDB and are running it as background process/service on your development machine. Follow [this guide](https://www.mongodb.com/docs/manual/installation/) for details.
-
----
-
-Once MongoDB is running, create a directory and initialize it with `bun init`.
-
-```sh terminal icon="terminal"
-mkdir mongoose-app
-cd mongoose-app
-bun init
-```
-
----
-
-Then add Mongoose as a dependency.
-
-```sh terminal icon="terminal"
-bun add mongoose
-```
-
----
-
-In `schema.ts` we'll declare and export a simple `Animal` model.
-
-```ts schema.ts icon="/icons/typescript.svg"
-import * as mongoose from "mongoose";
-
-const animalSchema = new mongoose.Schema(
-  {
-    title: { type: String, required: true },
-    sound: { type: String, required: true },
-  },
-  {
-    methods: {
-      speak() {
-        console.log(`${this.sound}!`);
-      },
-    },
-  },
-);
-
-export type Animal = mongoose.InferSchemaType<typeof animalSchema>;
-export const Animal = mongoose.model("Animal", animalSchema);
-```
-
----
-
-Now from `index.ts` we can import `Animal`, connect to MongoDB, and add some data to our database.
-
-```ts index.ts icon="/icons/typescript.svg"
-import * as mongoose from "mongoose";
-import { Animal } from "./schema";
-
-// connect to database
-await mongoose.connect("mongodb://127.0.0.1:27017/mongoose-app");
-
-// create new Animal
-const cow = new Animal({
-  title: "Cow",
-  sound: "Moo",
-});
-await cow.save(); // saves to the database
-
-// read all Animals
-const animals = await Animal.find();
-animals[0].speak(); // logs "Moo!"
-
-// disconnect
-await mongoose.disconnect();
-```
-
----
-
-Let's run this with `bun run`.
-
-```bash terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-Moo!
-```
-
----
-
-This is a simple introduction to using Mongoose with TypeScript and Bun. As you build your application, refer to the official [MongoDB](https://www.mongodb.com/docs) and [Mongoose](https://mongoosejs.com/docs/) sites for complete documentation.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/neon-drizzle.mdx

@@ -1,234 +0,0 @@
----
-title: Use Neon Postgres through Drizzle ORM
-sidebarTitle: Neon Drizzle with Bun
-mode: center
----
-
-[Neon](https://neon.tech/) is a fully managed serverless Postgres, separating compute and storage to offer features like autoscaling, branching and bottomless storage. Neon can be used from Bun directly using the `@neondatabase/serverless` driver or through an ORM like `Drizzle`.
-
-Drizzle ORM supports both a SQL-like "query builder" API and an ORM-like [Queries API](https://orm.drizzle.team/docs/rqb). Get started by creating a project directory, initializing the directory using `bun init`, and installing Drizzle and the [Neon serverless driver](https://github.com/neondatabase/serverless/).
-
-```sh terminal icon="terminal"
-mkdir bun-drizzle-neon
-cd bun-drizzle-neon
-bun init -y
-bun add drizzle-orm @neondatabase/serverless
-bun add -D drizzle-kit
-```
-
----
-
-Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
-
-```ini .env.local icon="settings"
-DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
-```
-
----
-
-We will connect to the Neon database using the Neon serverless driver, wrapped in a Drizzle database instance.
-
-```ts db.ts icon="/icons/typescript.svg"
-import { neon } from "@neondatabase/serverless";
-import { drizzle } from "drizzle-orm/neon-http";
-
-// Bun automatically loads the DATABASE_URL from .env.local
-// Refer to: https://bun.com/docs/runtime/environment-variables for more information
-const sql = neon(process.env.DATABASE_URL!);
-
-export const db = drizzle(sql);
-```
-
----
-
-To see the database in action, add these lines to `index.ts`.
-
-```ts index.ts icon="/icons/typescript.svg"
-import { db } from "./db";
-import { sql } from "drizzle-orm";
-
-const query = sql`select 'hello world' as text`;
-const result = await db.execute(query);
-console.log(result.rows);
-```
-
----
-
-Then run `index.ts` with Bun.
-
-```sh terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-[
-  {
-    text: "hello world",
-  }
-]
-```
-
----
-
-We can define a schema for our database using Drizzle ORM primitives. Create a `schema.ts` file and add this code.
-
-```ts schema.ts icon="/icons/typescript.svg"
-import { pgTable, integer, serial, text, timestamp } from "drizzle-orm/pg-core";
-
-export const authors = pgTable("authors", {
-  id: serial("id").primaryKey(),
-  title: text("name").notNull(),
-  bio: text("bio"),
-  createdAt: timestamp("created_at").notNull().defaultNow(),
-});
-```
-
----
-
-We then use the `drizzle-kit` CLI to generate an initial SQL migration.
-
-```sh
-bunx drizzle-kit generate --dialect postgresql --schema ./schema.ts --out ./drizzle
-```
-
----
-
-This creates a new `drizzle` directory containing a `.sql` migration file and `meta` directory.
-
-```txt File Tree icon="folder-tree"
-drizzle
-├── 0000_aspiring_post.sql
-└── meta
-    ├── 0000_snapshot.json
-    └── _journal.json
-```
-
----
-
-We can execute these migrations with a simple `migrate.ts` script. This script creates a new connection to the Neon database and executes all unexecuted migrations in the `drizzle` directory.
-
-```ts migrate.ts
-import { db } from "./db";
-import { migrate } from "drizzle-orm/neon-http/migrator";
-
-const main = async () => {
-  try {
-    await migrate(db, { migrationsFolder: "drizzle" });
-    console.log("Migration completed");
-  } catch (error) {
-    console.error("Error during migration:", error);
-    process.exit(1);
-  }
-};
-
-main();
-```
-
----
-
-We can run this script with `bun` to execute the migration.
-
-```sh terminal icon="terminal"
-bun run migrate.ts
-```
-
-```txt
-Migration completed
-```
-
----
-
-We can now add some data to our database. Create a `seed.ts` file with the following contents.
-
-```ts seed.ts icon="/icons/typescript.svg"
-import { db } from "./db";
-import * as schema from "./schema";
-
-async function seed() {
-  await db.insert(schema.authors).values([
-    {
-      title: "J.R.R. Tolkien",
-      bio: "The creator of Middle-earth and author of The Lord of the Rings.",
-    },
-    {
-      title: "George R.R. Martin",
-      bio: "The author of the epic fantasy series A Song of Ice and Fire.",
-    },
-    {
-      title: "J.K. Rowling",
-      bio: "The creator of the Harry Potter series.",
-    },
-  ]);
-}
-
-async function main() {
-  try {
-    await seed();
-    console.log("Seeding completed");
-  } catch (error) {
-    console.error("Error during seeding:", error);
-    process.exit(1);
-  }
-}
-
-main();
-```
-
----
-
-Then run this file.
-
-```sh terminal icon="terminal"
-bun run seed.ts
-```
-
-```txt
-Seeding completed
-```
-
----
-
-We now have a database with a schema and sample data. We can use Drizzle to query it. Replace the contents of `index.ts` with the following.
-
-```ts index.ts icon="/icons/typescript.svg"
-import * as schema from "./schema";
-import { db } from "./db";
-
-const result = await db.select().from(schema.authors);
-console.log(result);
-```
-
----
-
-Then run the file. You should see the three authors we inserted.
-
-```sh terminal icon="terminal"
-bun run index.ts
-```
-
-```txt
-[
-  {
-    id: 1,
-    title: "J.R.R. Tolkien",
-    bio: "The creator of Middle-earth and author of The Lord of the Rings.",
-    createdAt: 2024-05-11T10:28:46.029Z,
-  }, {
-    id: 2,
-    title: "George R.R. Martin",
-    bio: "The author of the epic fantasy series A Song of Ice and Fire.",
-    createdAt: 2024-05-11T10:28:46.029Z,
-  }, {
-    id: 3,
-    title: "J.K. Rowling",
-    bio: "The creator of the Harry Potter series.",
-    createdAt: 2024-05-11T10:28:46.029Z,
-  }
-]
-```
-
----
-
-This example used the Neon serverless driver's SQL-over-HTTP functionality. Neon's serverless driver also exposes `Client` and `Pool` constructors to enable sessions, interactive transactions, and node-postgres compatibility. Refer to [Neon's documentation](https://neon.tech/docs/serverless/serverless-driver) for a complete overview.
-
-Refer to the [Drizzle website](https://orm.drizzle.team/docs/overview) for more documentation on using the Drizzle ORM.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/neon-serverless-postgres.mdx

@@ -1,60 +0,0 @@
----
-title: Use Neon's Serverless Postgres with Bun
-sidebarTitle: Neon Serverless Postgres with Bun
-mode: center
----
-
-[Neon](https://neon.tech/) is a fully managed serverless Postgres. Neon separates compute and storage to offer modern developer features such as autoscaling, branching, bottomless storage, and more.
-
----
-
-Get started by creating a project directory, initializing the directory using `bun init`, and adding the [Neon serverless driver](https://github.com/neondatabase/serverless/) as a project dependency.
-
-```sh terminal icon="terminal"
-mkdir bun-neon-postgres
-cd bun-neon-postgres
-bun init -y
-bun add @neondatabase/serverless
-```
-
----
-
-Create a `.env.local` file and add your [Neon Postgres connection string](https://neon.tech/docs/connect/connect-from-any-app) to it.
-
-```ini .env.local icon="settings"
-DATABASE_URL=postgresql://usertitle:password@ep-adj-noun-guid.us-east-1.aws.neon.tech/neondb?sslmode=require
-```
-
----
-
-Paste the following code into your project's `index.ts` file.
-
-```ts index.ts icon="/icons/typescript.svg"
-import { neon } from "@neondatabase/serverless";
-
-// Bun automatically loads the DATABASE_URL from .env.local
-// Refer to: https://bun.com/docs/runtime/environment-variables for more information
-const sql = neon(process.env.DATABASE_URL);
-
-const rows = await sql`SELECT version()`;
-
-console.log(rows[0].version);
-```
-
----
-
-Start the program using `bun ./index.ts`. The Postgres version should be printed to the console.
-
-```sh terminal icon="terminal"
-bun ./index.ts
-```
-
-```txt
-PostgreSQL 16.2 on x86_64-pc-linux-gnu, compiled by gcc (Debian 10.2.1-6) 10.2.1 20210110, 64-bit
-```
-
----
-
-This example used the Neon serverless driver's SQL-over-HTTP functionality. Neon's serverless driver also exposes `Client` and `Pool` constructors to enable sessions, interactive transactions, and node-postgres compatibility.
-
-Refer to [Neon's documentation](https://neon.tech/docs/serverless/serverless-driver) for a complete overview of the serverless driver.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/nextjs.mdx

@@ -1,103 +0,0 @@
----
-title: Build an app with Next.js and Bun
-sidebarTitle: Next.js with Bun
-mode: center
----
-
-[Next.js](https://nextjs.org/) is a React framework for building full-stack web applications. It supports server-side rendering, static site generation, API routes, and more. Bun provides fast package installation and can run Next.js development and production servers.
-
----
-
-<Steps>
-  <Step title="Create a new Next.js app">
-    Use the interactive CLI to create a new Next.js app. This will scaffold a new Next.js project and automatically install dependencies.
-
-    ```sh terminal icon="terminal"
-    bun create next-app@latest my-bun-app
-    ```
-
-  </Step>
-  <Step title="Start the dev server">
-    Change to the project directory and run the dev server with Bun.
-
-    ```sh terminal icon="terminal"
-    cd my-bun-app
-    bun --bun run dev
-    ```
-
-    This starts the Next.js dev server with Bun's runtime.
-
-    Open [`http://localhost:3000`](http://localhost:3000) with your browser to see the result. Any changes you make to `app/page.tsx` will be hot-reloaded in the browser.
-
-  </Step>
-  <Step title="Update scripts in package.json">
-    Modify the scripts field in your `package.json` by prefixing the Next.js CLI commands with `bun --bun`. This ensures that Bun executes the Next.js CLI for common tasks like `dev`, `build`, and `start`.
-
-    ```json package.json icon="file-json"
-    {
-      "scripts": {
-        "dev": "bun --bun next dev", // [!code ++]
-        "build": "bun --bun next build", // [!code ++]
-        "start": "bun --bun next start", // [!code ++]
-      }
-    }
-    ```
-
-  </Step>
-</Steps>
-
----
-
-## Hosting
-
-Next.js applications on Bun can be deployed to various platforms.
-
-<Columns cols={3}>
-  <Card title="Vercel" href="/guides/deployment/vercel" icon="/icons/ecosystem/vercel.svg">
-    Deploy on Vercel
-  </Card>
-  <Card title="Railway" href="/guides/deployment/railway" icon="/icons/ecosystem/railway.svg">
-    Deploy on Railway
-  </Card>
-  <Card title="DigitalOcean" href="/guides/deployment/digital-ocean" icon="/icons/ecosystem/digitalocean.svg">
-    Deploy on DigitalOcean
-  </Card>
-  <Card title="AWS Lambda" href="/guides/deployment/aws-lambda" icon="/icons/ecosystem/aws.svg">
-    Deploy on AWS Lambda
-  </Card>
-  <Card title="Google Cloud Run" href="/guides/deployment/google-cloud-run" icon="/icons/ecosystem/gcp.svg">
-    Deploy on Google Cloud Run
-  </Card>
-  <Card title="Render" href="/guides/deployment/render" icon="/icons/ecosystem/render.svg">
-    Deploy on Render
-  </Card>
-</Columns>
-
----
-
-## Templates
-
-<Columns cols={2}>
-  <Card
-    title="Bun + Next.js Basic Starter"
-    img="/images/templates/bun-nextjs-basic.png"
-    href="https://github.com/bun-templates/bun-nextjs-basic"
-    arrow="true"
-    cta="Go to template"
-  >
-    A simple App Router starter with Bun, Next.js, and Tailwind CSS.
-  </Card>
-  <Card
-    title="Todo App with Next.js + Bun"
-    img="/images/templates/bun-nextjs-todo.png"
-    href="https://github.com/bun-templates/bun-nextjs-todo"
-    arrow="true"
-    cta="Go to template"
-  >
-    A full-stack todo application built with Bun, Next.js, and PostgreSQL.
-  </Card>
-</Columns>
-
----
-
-[→ See Next.js's official documentation](https://nextjs.org/docs) for more information on building and deploying Next.js applications.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/nuxt.mdx

@@ -1,96 +0,0 @@
----
-title: Build an app with Nuxt and Bun
-sidebarTitle: Nuxt with Bun
-mode: center
----
-
-Bun supports [Nuxt](https://nuxt.com) out of the box. Initialize a Nuxt app with official `nuxi` CLI.
-
-```sh terminal icon="terminal"
-bunx nuxi init my-nuxt-app
-```
-
-```txt
-✔ Which package manager would you like to use?
-bun
-◐ Installing dependencies...
-bun install v1.3.3 (16b4bf34)
- + @nuxt/devtools@0.8.2
- + nuxt@3.7.0
- 785 packages installed [2.67s]
-✔ Installation completed.
-✔ Types generated in .nuxt
-✨ Nuxt project has been created with the v3 template. Next steps:
- › cd my-nuxt-app
- › Start development server with bun run dev
-```
-
----
-
-To start the dev server, run `bun --bun run dev` from the project root. This will execute the `nuxt dev` command (as defined in the `"dev"` script in `package.json`).
-
-<Note>
-  The `nuxt` CLI uses Node.js by default; passing the `--bun` flag forces the dev server to use the Bun runtime instead.
-</Note>
-
-```sh terminal icon="terminal"
-cd my-nuxt-app
-bun --bun run dev
-```
-
-```txt
-nuxt dev
-Nuxi 3.6.5
-Nuxt 3.6.5 with Nitro 2.5.2
-  > Local:    http://localhost:3000/
-  > Network:  http://192.168.0.21:3000/
-  > Network:  http://[fd8a:d31d:481c:4883:1c64:3d90:9f83:d8a2]:3000/
-
-✔ Nuxt DevTools is enabled v0.8.0 (experimental)
-ℹ Vite client warmed up in 547ms
-✔ Nitro built in 244 ms
-```
-
----
-
-Once the dev server spins up, open [http://localhost:3000](http://localhost:3000) to see the app. The app will render Nuxt's built-in `NuxtWelcome` template component.
-
-To start developing your app, replace `<NuxtWelcome />` in `app.vue` with your own UI.
-
-<Frame>
-  ![Demo Nuxt app running on
-  localhost](https://github.com/oven-sh/bun/assets/3084745/2c683ecc-3298-4bb0-b8c0-cf4cfaea1daa)
-</Frame>
-
----
-
-For production build, while the default preset is already compatible with Bun, you can also use [Bun preset](https://nitro.build/deploy/runtimes/bun) to generate better optimized builds.
-
-```ts nuxt.config.ts icon="/icons/typescript.svg"
-export default defineNuxtConfig({
-  nitro: {
-    preset: "bun", // [!code ++]
-  },
-});
-```
-
-Alternatively, you can set the preset via environment variable:
-
-```sh terminal icon="terminal"
-NITRO_PRESET=bun bun run build
-```
-
-<Note>
-  Some packages provide Bun-specific exports that Nitro will not bundle correctly using the default preset. In this
-  case, you need to use Bun preset so that the packages will work correctly in production builds.
-</Note>
-
-After building with bun, run:
-
-```sh terminal icon="terminal"
-bun run ./.output/server/index.mjs
-```
-
----
-
-Refer to the [Nuxt website](https://nuxt.com/docs) for complete documentation.

package/skills/skill-logo-design/node_modules/bun-types/docs/guides/ecosystem/pm2.mdx

@@ -1,55 +0,0 @@
----
-title: Run Bun as a daemon with PM2
-sidebarTitle: PM2 with Bun
-mode: center
----
-
-[PM2](https://pm2.keymetrics.io/) is a popular process manager that manages and runs your applications as daemons (background processes).
-
-It offers features like process monitoring, automatic restarts, and easy scaling. Using a process manager is common when deploying a Bun application on a cloud-hosted virtual private server (VPS), as it:
-
-- Keeps your Node.js application running continuously.
-- Ensure high availability and reliability of your application.
-- Monitor and manage multiple processes with ease.
-- Simplify the deployment process.
-
----
-
-You can use PM2 with Bun in two ways: as a CLI option or in a configuration file.
-
-### With `--interpreter`
-
-To start your application with PM2 and Bun as the interpreter, open your terminal and run the following command:
-
-```bash terminal icon="terminal"
-pm2 start --interpreter ~/.bun/bin/bun index.ts
-```
-
----
-
-### With a configuration file
-
-Alternatively, you can create a PM2 configuration file. Create a file named `pm2.config.js` in your project directory and add the following content.
-
-```js pm2.config.js icon="file-code"
-module.exports = {
-  name: "app", // Name of your application
-  script: "index.ts", // Entry point of your application
-  interpreter: "bun", // Bun interpreter
-  env: {
-    PATH: `${process.env.HOME}/.bun/bin:${process.env.PATH}`, // Add "~/.bun/bin/bun" to PATH
-  },
-};
-```
-
----
-
-After saving the file, you can start your application with PM2
-
-```bash terminal icon="terminal"
-pm2 start pm2.config.js
-```
-
----
-
-That’s it! Your JavaScript/TypeScript web server is now running as a daemon with PM2 using Bun as the interpreter.