@hasna/connectors 1.3.3 → 1.3.5

package/connectors/{connect-yousign → connect-namecheap}/node_modules/bun-types/docs/runtime/markdown.mdx

@@ -124,22 +124,32 @@ Return a string to replace the element's rendering. Return `null` or `undefined`
 
 ### Block callbacks
 
-| Callback     | Meta                                        | Description                                                                              |
-| ------------ | ------------------------------------------- | ---------------------------------------------------------------------------------------- |
-| `heading`    | `{ level: number, id?: string }`            | Heading level 1–6. `id` is set when `headings: { ids: true }` is enabled                 |
-| `paragraph`  | —                                           | Paragraph block                                                                          |
-| `blockquote` | —                                           | Blockquote block                                                                         |
-| `code`       | `{ language?: string }`                     | Fenced or indented code block. `language` is the info-string when specified on the fence |
-| `list`       | `{ ordered: boolean, start?: number }`      | Ordered or unordered list. `start` is the start number for ordered lists                 |
-| `listItem`   | `{ checked?: boolean }`                     | List item. `checked` is set for task list items (`- [x]` / `- [ ]`)                      |
-| `hr`         | —                                           | Horizontal rule                                                                          |
-| `table`      | —                                           | Table block                                                                              |
-| `thead`      | —                                           | Table head                                                                               |
-| `tbody`      | —                                           | Table body                                                                               |
-| `tr`         | —                                           | Table row                                                                                |
-| `th`         | `{ align?: "left" \| "center" \| "right" }` | Table header cell. `align` is set when alignment is specified                            |
-| `td`         | `{ align?: "left" \| "center" \| "right" }` | Table data cell. `align` is set when alignment is specified                              |
-| `html`       | —                                           | Raw HTML content                                                                         |
+| Callback     | Meta                                          | Description                                                                              |
+| ------------ | --------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `heading`    | `{ level, id? }`                              | Heading level 1–6. `id` is set when `headings: { ids: true }` is enabled                 |
+| `paragraph`  | —                                             | Paragraph block                                                                          |
+| `blockquote` | —                                             | Blockquote block                                                                         |
+| `code`       | `{ language? }`                               | Fenced or indented code block. `language` is the info-string when specified on the fence |
+| `list`       | `{ ordered, start?, depth }`                  | `depth` is nesting level (0 = top-level). `start` is set for ordered lists               |
+| `listItem`   | `{ index, depth, ordered, start?, checked? }` | See [List item meta](#list-item-meta) below                                              |
+| `hr`         | —                                             | Horizontal rule                                                                          |
+| `table`      | —                                             | Table block                                                                              |
+| `thead`      | —                                             | Table head                                                                               |
+| `tbody`      | —                                             | Table body                                                                               |
+| `tr`         | —                                             | Table row                                                                                |
+| `th`         | `{ align? }`                                  | Table header cell. `align` is `"left"`, `"center"`, `"right"`, or absent                 |
+| `td`         | `{ align? }`                                  | Table data cell                                                                          |
+| `html`       | —                                             | Raw HTML content                                                                         |
+
+#### List item meta
+
+The `listItem` callback receives everything needed to render markers directly:
+
+- `index` — 0-based position within the parent list
+- `depth` — the parent list's nesting level (0 = top-level)
+- `ordered` — whether the parent list is ordered
+- `start` — the parent list's start number (only when `ordered` is true)
+- `checked` — task list state (only for `- [x]` / `- [ ]` items)
 
 ### Inline callbacks
 
@@ -205,6 +215,33 @@ const ansi = Bun.markdown.render("# Hello\n\nThis is **bold** and *italic*", {
 });
 ```
 
+#### Nested list numbering
+
+The `listItem` callback receives everything needed to render markers directly — no post-processing:
+
+```ts
+const result = Bun.markdown.render("1. first\n   1. sub-a\n   2. sub-b\n2. second", {
+  listItem: (children, { index, depth, ordered, start }) => {
+    const n = (start ?? 1) + index;
+    // 1. 2. 3. at depth 0, a. b. c. at depth 1, i. ii. iii. at depth 2
+    const marker = !ordered
+      ? "-"
+      : depth === 0
+        ? `${n}.`
+        : depth === 1
+          ? `${String.fromCharCode(96 + n)}.`
+          : `${toRoman(n)}.`;
+    return "  ".repeat(depth) + marker + " " + children.trimEnd() + "\n";
+  },
+  // Prepend a newline so nested lists are separated from their parent item's text
+  list: children => "\n" + children,
+});
+// 1. first
+//   a. sub-a
+//   b. sub-b
+// 2. second
+```
+
 #### Code block syntax highlighting
 
 ````ts

package/connectors/connect-namecheap/node_modules/bun-types/docs/runtime/toml.mdx

@@ -0,0 +1,238 @@
+---
+title: TOML
+description: Use Bun's built-in support for TOML files through both runtime APIs and bundler integration
+---
+
+In Bun, TOML is a first-class citizen alongside JSON, JSON5, and YAML. You can:
+
+- Parse TOML strings with `Bun.TOML.parse`
+- `import` & `require` TOML files as modules at runtime (including hot reloading & watch mode support)
+- `import` & `require` TOML files in frontend apps via Bun's bundler
+
+---
+
+## Runtime API
+
+### `Bun.TOML.parse()`
+
+Parse a TOML string into a JavaScript object.
+
+```ts
+import { TOML } from "bun";
+const text = `
+name = "my-app"
+version = "1.0.0"
+debug = true
+
+[database]
+host = "localhost"
+port = 5432
+
+[features]
+tags = ["web", "api"]
+`;
+
+const data = TOML.parse(text);
+console.log(data);
+// {
+//   name: "my-app",
+//   version: "1.0.0",
+//   debug: true,
+//   database: { host: "localhost", port: 5432 },
+//   features: { tags: ["web", "api"] }
+// }
+```
+
+#### Supported TOML Features
+
+Bun's TOML parser supports the [TOML v1.0 specification](https://toml.io/en/v1.0.0), including:
+
+- **Strings**: basic (`"..."`) and literal (`'...'`), including multi-line
+- **Integers**: decimal, hex (`0x`), octal (`0o`), and binary (`0b`)
+- **Floats**: including `inf` and `nan`
+- **Booleans**: `true` and `false`
+- **Arrays**: including mixed types and nested arrays
+- **Tables**: standard (`[table]`) and inline (`{ key = "value" }`)
+- **Array of tables**: `[[array]]`
+- **Dotted keys**: `a.b.c = "value"`
+- **Comments**: using `#`
+
+```ts
+const data = Bun.TOML.parse(`
+# Application config
+title = "My App"
+
+[owner]
+name = "John Doe"
+
+[database]
+enabled = true
+ports = [8000, 8001, 8002]
+connection_max = 5000
+
+[servers.alpha]
+ip = "10.0.0.1"
+role = "frontend"
+
+[servers.beta]
+ip = "10.0.0.2"
+role = "backend"
+`);
+```
+
+#### Error Handling
+
+`Bun.TOML.parse()` throws if the TOML is invalid:
+
+```ts
+try {
+  Bun.TOML.parse("invalid = = =");
+} catch (error) {
+  console.error("Failed to parse TOML:", error.message);
+}
+```
+
+---
+
+## Module Import
+
+### ES Modules
+
+You can import TOML files directly as ES modules. The TOML content is parsed and made available as both default and named exports:
+
+```toml config.toml
+[database]
+host = "localhost"
+port = 5432
+name = "myapp"
+
+[redis]
+host = "localhost"
+port = 6379
+
+[features]
+auth = true
+rateLimit = true
+analytics = false
+```
+
+#### Default Import
+
+```ts app.ts icon="/icons/typescript.svg"
+import config from "./config.toml";
+
+console.log(config.database.host); // "localhost"
+console.log(config.redis.port); // 6379
+```
+
+#### Named Imports
+
+You can destructure top-level TOML tables as named imports:
+
+```ts app.ts icon="/icons/typescript.svg"
+import { database, redis, features } from "./config.toml";
+
+console.log(database.host); // "localhost"
+console.log(redis.port); // 6379
+console.log(features.auth); // true
+```
+
+Or combine both:
+
+```ts app.ts icon="/icons/typescript.svg"
+import config, { database, features } from "./config.toml";
+
+// Use the full config object
+console.log(config);
+
+// Or use specific parts
+if (features.rateLimit) {
+  setupRateLimiting(database);
+}
+```
+
+#### Import Attributes
+
+You can also use import attributes to load any file as TOML:
+
+```ts app.ts icon="/icons/typescript.svg"
+import myConfig from "./my.config" with { type: "toml" };
+```
+
+### CommonJS
+
+TOML files can also be required in CommonJS:
+
+```ts app.ts icon="/icons/typescript.svg"
+const config = require("./config.toml");
+console.log(config.database.name); // "myapp"
+
+// Destructuring also works
+const { database, redis } = require("./config.toml");
+console.log(database.port); // 5432
+```
+
+---
+
+## Hot Reloading with TOML
+
+When you run your application with `bun --hot`, changes to TOML files are automatically detected and reloaded without restarting:
+
+```toml config.toml
+[server]
+port = 3000
+host = "localhost"
+
+[features]
+debug = true
+verbose = false
+```
+
+```ts server.ts icon="/icons/typescript.svg"
+import { server, features } from "./config.toml";
+
+console.log(`Starting server on ${server.host}:${server.port}`);
+
+Bun.serve({
+  port: server.port,
+  hostname: server.host,
+  fetch(req) {
+    if (features.verbose) {
+      console.log(`${req.method} ${req.url}`);
+    }
+    return new Response("Hello World");
+  },
+});
+```
+
+Run with hot reloading:
+
+```bash terminal icon="terminal"
+bun --hot server.ts
+```
+
+Now when you modify `config.toml`, the changes are immediately reflected in your running application.
+
+---
+
+## Bundler Integration
+
+When you import TOML files and bundle with Bun, the TOML is parsed at build time and included as a JavaScript module:
+
+```bash terminal icon="terminal"
+bun build app.ts --outdir=dist
+```
+
+This means:
+
+- Zero runtime TOML parsing overhead in production
+- Smaller bundle sizes
+- Tree-shaking support for unused properties (named imports)
+
+### Dynamic Imports
+
+TOML files can be dynamically imported:
+
+```ts
+const config = await import("./config.toml");
+```

package/connectors/{connect-yousign → connect-namecheap}/node_modules/bun-types/docs/runtime/yaml.mdx

@@ -455,7 +455,7 @@ YAML files can be dynamically imported, useful for loading configuration on dema
 
 ```ts Load configuration based on environment
 const env = process.env.NODE_ENV || "development";
-const config = await import(`./configs/${env}.yaml`);
+const { default: config } = await import(`./configs/${env}.yaml`);
 
 // Load user-specific settings
 async function loadUserSettings(userId: string) {
@@ -463,7 +463,8 @@ async function loadUserSettings(userId: string) {
     const settings = await import(`./users/${userId}/settings.yaml`);
     return settings.default;
   } catch {
-    return await import("./users/default-settings.yaml");
+    const { default: defaults } = await import("./users/default-settings.yaml");
+    return defaults;
   }
 }
 ```

package/connectors/{connect-yousign → connect-namecheap}/node_modules/bun-types/docs/test/configuration.mdx

@@ -91,6 +91,59 @@ mock.module("./external-api", () => ({
 }));
 ```
 
+### Path Ignore Patterns
+
+Exclude files and directories from test discovery entirely using glob patterns. Unlike `coveragePathIgnorePatterns` which only affects coverage reports, `pathIgnorePatterns` prevents matching paths from being discovered and run as tests.
+
+This is useful when your project contains submodules, vendored code, or other directories with `*.test.ts` files that you don't want `bun test` to pick up.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+# Single pattern
+pathIgnorePatterns = "vendor/**"
+
+# Multiple patterns
+pathIgnorePatterns = [
+  "vendor/**",
+  "submodules/**",
+  "fixtures/**"
+]
+```
+
+This is equivalent to using `--path-ignore-patterns` on the command line:
+
+```bash terminal icon="terminal"
+bun test --path-ignore-patterns 'vendor/**' --path-ignore-patterns 'fixtures/**'
+```
+
+Directories matching a pattern are pruned during scanning, so their contents are never traversed. This means ignoring a large directory tree is efficient -- Bun won't spend time reading files inside it.
+
+#### Common Use Cases
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+pathIgnorePatterns = [
+  # Git submodules with their own test suites
+  "submodules/**",
+
+  # Vendored dependencies
+  "vendor/**",
+  "third-party/**",
+
+  # Test fixtures that look like tests but aren't
+  "fixtures/**",
+  "**/test-data/**",
+
+  # Integration / E2E tests you want to run separately
+  "**/integration/**",
+  "e2e/**"
+]
+```
+
+<Note>
+  Command-line `--path-ignore-patterns` flags override the `bunfig.toml` value entirely -- the two are not merged.
+</Note>
+
 ## Timeouts
 
 ### Default Timeout
@@ -415,6 +468,7 @@ exact = true
 # Test discovery
 root = "src"
 preload = ["./test-setup.ts", "./global-mocks.ts"]
+pathIgnorePatterns = ["vendor/**", "submodules/**"]
 
 # Execution settings
 timeout = 10000

package/connectors/{connect-yousign → connect-namecheap}/node_modules/bun-types/package.json

@@ -33,5 +33,5 @@
     "bun.js",
     "types"
   ],
-  "version": "1.3.10"
+  "version": "1.3.11"
 }

package/connectors/{connect-yousign → connect-namecheap}/node_modules/bun-types/s3.d.ts

@@ -299,6 +299,25 @@ declare module "bun" {
      */
     contentDisposition?: string | undefined;
 
+    /**
+     * The Content-Encoding header value.
+     * Specifies what content encodings have been applied to the object,
+     * for example to indicate that it has been compressed.
+     *
+     * @example
+     *    // Setting gzip encoding
+     *     const file = s3.file("data.json.gz", {
+     *       contentEncoding: "gzip"
+     *     });
+     *
+     * @example
+     *    // Setting encoding when writing
+     *     await s3.write("data.json.gz", compressedData, {
+     *       contentEncoding: "gzip"
+     *     });
+     */
+    contentEncoding?: string | undefined;
+
     /**
      * By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects.
      *

package/connectors/connect-namecheap/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hasna/connect-namecheap",
+  "version": "0.1.0",
+  "description": "Namecheap API connector - A TypeScript CLI for managing domains and DNS via the Namecheap XML API",
+  "type": "module",
+  "bin": {
+    "connect-namecheap": "./bin/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "api",
+    "connector",
+    "namecheap",
+    "domains",
+    "dns",
+    "cli",
+    "typescript",
+    "bun",
+    "hasna"
+  ],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasna/connectors.git"
+  }
+}

package/connectors/connect-namecheap/src/api/client.ts

@@ -0,0 +1,82 @@
+import type { ConnectorConfig } from '../types';
+import { ConnectorApiError } from '../types';
+import { checkApiError } from '../utils/xml';
+
+// Namecheap API base URLs
+const API_BASE = 'https://api.namecheap.com/xml.response';
+const SANDBOX_BASE = 'https://api.sandbox.namecheap.com/xml.response';
+
+/**
+ * Low-level HTTP client for the Namecheap XML API.
+ * Handles URL building, authentication params, and XML error checking.
+ */
+export class ConnectorClient {
+  private readonly apiKey: string;
+  private readonly username: string;
+  private readonly clientIp: string;
+  private readonly baseUrl: string;
+
+  constructor(config: ConnectorConfig) {
+    if (!config.apiKey) {
+      throw new Error('API key is required');
+    }
+    if (!config.username) {
+      throw new Error('Username is required');
+    }
+    if (!config.clientIp) {
+      throw new Error('Client IP is required');
+    }
+    this.apiKey = config.apiKey;
+    this.username = config.username;
+    this.clientIp = config.clientIp;
+    this.baseUrl = config.sandbox ? SANDBOX_BASE : API_BASE;
+  }
+
+  /**
+   * Build a full Namecheap API URL with auth params and command
+   */
+  buildUrl(command: string, extraParams?: Record<string, string>): string {
+    const params = new URLSearchParams({
+      ApiUser: this.username,
+      ApiKey: this.apiKey,
+      UserName: this.username,
+      ClientIp: this.clientIp,
+      Command: command,
+      ...extraParams,
+    });
+    return `${this.baseUrl}?${params.toString()}`;
+  }
+
+  /**
+   * Make an authenticated request to the Namecheap XML API
+   * Returns raw XML string after error checking
+   */
+  async request(command: string, extraParams?: Record<string, string>): Promise<string> {
+    const url = this.buildUrl(command, extraParams);
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(30000),
+      headers: { 'User-Agent': 'connect-namecheap/0.1.0' },
+    });
+
+    if (!response.ok) {
+      throw new ConnectorApiError(
+        `Namecheap API HTTP error: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+
+    const xml = await response.text();
+    checkApiError(xml);
+    return xml;
+  }
+
+  /**
+   * Get a preview of the API key (for display/debugging)
+   */
+  getApiKeyPreview(): string {
+    if (this.apiKey.length > 10) {
+      return `${this.apiKey.substring(0, 6)}...${this.apiKey.substring(this.apiKey.length - 4)}`;
+    }
+    return '***';
+  }
+}

package/connectors/connect-namecheap/src/api/dns.ts

@@ -0,0 +1,74 @@
+import type { ConnectorClient } from './client';
+import type { DnsRecord } from '../types';
+import { extractAllTags, extractAttributeFromElement } from '../utils/xml';
+
+/**
+ * Namecheap DNS API
+ * Commands: namecheap.domains.dns.getHosts, setHosts
+ */
+export class DnsApi {
+  constructor(private readonly client: ConnectorClient) {}
+
+  /**
+   * Get DNS host records for a domain
+   * Command: namecheap.domains.dns.getHosts
+   */
+  async getHosts(sld: string, tld: string): Promise<DnsRecord[]> {
+    const xml = await this.client.request('namecheap.domains.dns.getHosts', {
+      SLD: sld,
+      TLD: tld,
+    });
+
+    const hostElements = extractAllTags(xml, 'host');
+    const records: DnsRecord[] = [];
+
+    for (const el of hostElements) {
+      const type = extractAttributeFromElement(el, 'Type');
+      const name = extractAttributeFromElement(el, 'Name');
+      const address = extractAttributeFromElement(el, 'Address');
+      const hostId = extractAttributeFromElement(el, 'HostId');
+      const mxPref = extractAttributeFromElement(el, 'MXPref');
+      const ttl = extractAttributeFromElement(el, 'TTL');
+
+      if (type && name && address) {
+        records.push({
+          hostId: hostId || undefined,
+          type,
+          name,
+          address,
+          mxPref: mxPref ? parseInt(mxPref) : undefined,
+          ttl: ttl ? parseInt(ttl) : 1800,
+        });
+      }
+    }
+
+    return records;
+  }
+
+  /**
+   * Set DNS host records for a domain
+   * Command: namecheap.domains.dns.setHosts
+   * NOTE: This replaces ALL records — you must include existing records you want to keep
+   */
+  async setHosts(sld: string, tld: string, records: DnsRecord[]): Promise<boolean> {
+    const params: Record<string, string> = {
+      SLD: sld,
+      TLD: tld,
+    };
+
+    for (let i = 0; i < records.length; i++) {
+      const r = records[i];
+      const idx = i + 1;
+      params[`HostName${idx}`] = r.name;
+      params[`RecordType${idx}`] = r.type;
+      params[`Address${idx}`] = r.address;
+      params[`TTL${idx}`] = String(r.ttl);
+      if (r.mxPref !== undefined) {
+        params[`MXPref${idx}`] = String(r.mxPref);
+      }
+    }
+
+    await this.client.request('namecheap.domains.dns.setHosts', params);
+    return true;
+  }
+}