@oscharko-dev/keiko 0.2.0-beta.0 → 0.2.0-beta.2

package/node_modules/@napi-rs/canvas/load-image.js

@@ -1,156 +0,0 @@
-const fs = require('fs')
-const { Readable } = require('stream')
-const { URL } = require('url')
-
-const { Image } = require('./js-binding')
-
-let http, https
-
-const MAX_REDIRECTS = 20
-const REDIRECT_STATUSES = new Set([301, 302])
-
-/**
- * Loads the given source into canvas Image
- * @param {string|URL|Image|Buffer} source The image source to be loaded
- * @param {object} options Options passed to the loader
- */
-module.exports = async function loadImage(source, options = {}) {
-  // use the same buffer without copying if the source is a buffer
-  if (Buffer.isBuffer(source) || source instanceof Uint8Array) return createImage(source, options.alt)
-  // load readable stream as image
-  if (source instanceof Readable) return createImage(await consumeStream(source), options.alt)
-  // construct a Uint8Array if the source is ArrayBuffer or SharedArrayBuffer
-  if (source instanceof ArrayBuffer || source instanceof SharedArrayBuffer)
-    return createImage(new Uint8Array(source), options.alt)
-  // construct a buffer if the source is buffer-like
-  if (isBufferLike(source)) return createImage(Buffer.from(source), options.alt)
-  // if the source is Image instance, copy the image src to new image
-  if (source instanceof Image) return createImage(source.src, options.alt)
-  // if source is string and in data uri format, construct image using data uri
-  if (typeof source === 'string' && source.trimStart().startsWith('data:')) {
-    const commaIdx = source.indexOf(',')
-    const encoding = source.lastIndexOf('base64', commaIdx) < 0 ? 'utf-8' : 'base64'
-    const data = Buffer.from(source.slice(commaIdx + 1), encoding)
-    // Empty payload would silently complete on Image (HTML spec) and the loadImage
-    // promise would never settle; reject upfront instead.
-    // See https://github.com/Brooooooklyn/canvas/issues/1255
-    if (data.length === 0) throw new Error(`Invalid data URI: empty payload in ${source.slice(0, 64)}`)
-    return createImage(data, options.alt)
-  }
-  // if source is a string or URL instance
-  if (typeof source === 'string') {
-    // if the source exists as a file, construct image from that file
-    if (!source.startsWith('http') && !source.startsWith('https') && (await exists(source))) {
-      return createImage(source, options.alt)
-    } else {
-      // the source is a remote url here
-      source = new URL(source)
-      // attempt to download the remote source and construct image
-      const data = await new Promise((resolve, reject) =>
-        makeRequest(
-          source,
-          resolve,
-          reject,
-          typeof options.maxRedirects === 'number' && options.maxRedirects >= 0 ? options.maxRedirects : MAX_REDIRECTS,
-          options.requestOptions,
-        ),
-      )
-      return createImage(data, options.alt)
-    }
-  }
-
-  if (source instanceof URL) {
-    if (source.protocol === 'file:') {
-      // remove the leading slash on windows
-      return createImage(process.platform === 'win32' ? source.pathname.substring(1) : source.pathname, options.alt)
-    } else {
-      const data = await new Promise((resolve, reject) =>
-        makeRequest(
-          source,
-          resolve,
-          reject,
-          typeof options.maxRedirects === 'number' && options.maxRedirects >= 0 ? options.maxRedirects : MAX_REDIRECTS,
-          options.requestOptions,
-        ),
-      )
-      return createImage(data, options.alt)
-    }
-  }
-
-  // throw error as don't support that source
-  throw new TypeError('unsupported image source')
-}
-
-function makeRequest(url, resolve, reject, redirectCount, requestOptions) {
-  const isHttps = url.protocol === 'https:'
-  // lazy load the lib
-  const lib = isHttps ? (!https ? (https = require('https')) : https) : !http ? (http = require('http')) : http
-
-  lib
-    .get(url.toString(), requestOptions || {}, (res) => {
-      try {
-        const shouldRedirect = REDIRECT_STATUSES.has(res.statusCode) && typeof res.headers.location === 'string'
-        if (shouldRedirect && redirectCount > 0)
-          return makeRequest(
-            new URL(res.headers.location, url.origin),
-            resolve,
-            reject,
-            redirectCount - 1,
-            requestOptions,
-          )
-        if (typeof res.statusCode === 'number' && (res.statusCode < 200 || res.statusCode >= 300)) {
-          return reject(new Error(`remote source rejected with status code ${res.statusCode}`))
-        }
-
-        consumeStream(res).then(resolve, reject)
-      } catch (err) {
-        reject(err)
-      }
-    })
-    .on('error', reject)
-}
-
-// use stream/consumers in the future?
-function consumeStream(res) {
-  return new Promise((resolve, reject) => {
-    const chunks = []
-
-    res.on('data', (chunk) => chunks.push(chunk))
-    res.on('end', () => resolve(Buffer.concat(chunks)))
-    res.on('error', reject)
-  })
-}
-
-async function createImage(src, alt) {
-  // Empty Buffer / Uint8Array: Image follows the HTML spec (silent completion,
-  // no events) so the promise below would hang. Reject upfront.
-  // See https://github.com/Brooooooklyn/canvas/issues/1255
-  if ((Buffer.isBuffer(src) || src instanceof Uint8Array) && src.length === 0) {
-    throw new Error('loadImage: empty image data')
-  }
-
-  const image = new Image()
-  if (typeof alt === 'string') image.alt = alt
-
-  return new Promise((resolve, reject) => {
-    image.onload = () => {
-      // Wait for bitmap decode before resolving
-      image.decode().then(() => resolve(image), reject)
-    }
-    image.onerror = (e) => reject(e)
-    image.src = src
-  })
-}
-
-function isBufferLike(src) {
-  return (src && src.type === 'Buffer') || Array.isArray(src)
-}
-
-async function exists(path) {
-  try {
-    await fs.promises.access(path, fs.constants.F_OK)
-    return true
-  } catch {
-    return false
-  }
-}

package/node_modules/@napi-rs/canvas/node-canvas.d.ts

@@ -1,216 +0,0 @@
-/**
- * node-canvas compatibility layer for @napi-rs/canvas.
- *
- * Provides a drop-in replacement API matching the `canvas` (node-canvas) npm package.
- * Quality values for JPEG/WebP use the node-canvas 0-1 scale and are automatically
- * converted to @napi-rs/canvas's 0-100 scale internally.
- *
- * @example
- * ```typescript
- * // Drop-in replacement: change this import
- * // import { createCanvas, registerFont, loadImage } from 'canvas'
- * // to this:
- * import { createCanvas, registerFont, loadImage } from '@napi-rs/canvas/node-canvas'
- * ```
- */
-
-import { Readable } from 'node:stream'
-
-// Re-export types from @napi-rs/canvas that are API-compatible
-import {
-  Image as NapiImage,
-  ImageData as NapiImageData,
-  Path2D as NapiPath2D,
-  DOMPoint as NapiDOMPoint,
-  DOMMatrix as NapiDOMMatrix,
-  DOMRect as NapiDOMRect,
-  SKRSContext2D,
-  Canvas as NapiCanvas,
-  SvgCanvas,
-  SvgExportFlag,
-  IGlobalFonts,
-  PDFDocument,
-} from './index'
-
-// ---------------------------------------------------------------------------
-// Config interfaces (node-canvas conventions)
-// ---------------------------------------------------------------------------
-
-export interface PngConfig {
-  /** ZLIB compression level (0-9). Accepted for compatibility; Skia uses its own encoder. */
-  compressionLevel?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
-  /** PNG filter flags. Accepted for compatibility; Skia uses its own encoder. */
-  filters?: number
-  /** Palette for indexed PNGs. Not supported by Skia backend. */
-  palette?: Uint8ClampedArray
-  /** Background color index for indexed PNGs. Not supported by Skia backend. */
-  backgroundIndex?: number
-  /** Pixels per inch. Accepted for compatibility. */
-  resolution?: number
-}
-
-export interface JpegConfig {
-  /** Quality between 0 and 1. Defaults to 0.75. Converted to 0-100 for Skia. */
-  quality?: number
-  /** Progressive encoding. Accepted for compatibility; not supported by Skia backend. */
-  progressive?: boolean
-  /** 2x2 chroma subsampling. Accepted for compatibility; not supported by Skia backend. */
-  chromaSubsampling?: boolean
-}
-
-// ---------------------------------------------------------------------------
-// Canvas class (with node-canvas compatible methods)
-// ---------------------------------------------------------------------------
-
-export interface Canvas extends Omit<NapiCanvas, 'toBuffer' | 'toDataURL'> {
-  /**
-   * Encode the canvas as a PNG and return a Node.js Readable stream.
-   * @param config PNG encoding options (accepted for compatibility)
-   */
-  createPNGStream(config?: PngConfig): PNGStream
-
-  /**
-   * Encode the canvas as a JPEG and return a Node.js Readable stream.
-   * @param config JPEG encoding options. Quality is 0-1 (default 0.75).
-   */
-  createJPEGStream(config?: JpegConfig): JPEGStream
-
-  // --- toBuffer overloads (node-canvas conventions) ---
-
-  /** Encode as PNG (default). */
-  toBuffer(): Buffer
-  toBuffer(mimeType: 'image/png', config?: PngConfig): Buffer
-  /** Encode as JPEG. Quality in config is 0-1 (default 0.75). */
-  toBuffer(mimeType: 'image/jpeg', config?: JpegConfig): Buffer
-  /** Get raw unencoded pixel data. */
-  toBuffer(mimeType: 'raw'): Buffer
-
-  /** Async: encode as PNG (default) via callback. */
-  toBuffer(cb: (err: Error | null, result: Buffer) => void): void
-  toBuffer(cb: (err: Error | null, result: Buffer) => void, mimeType: 'image/png', config?: PngConfig): void
-  /** Async: encode as JPEG via callback. Quality in config is 0-1 (default 0.75). */
-  toBuffer(cb: (err: Error | null, result: Buffer) => void, mimeType: 'image/jpeg', config?: JpegConfig): void
-
-  // --- toDataURL overloads (node-canvas conventions) ---
-
-  /** Encode as PNG data URL (default). */
-  toDataURL(): string
-  toDataURL(mimeType: 'image/png'): string
-  /** Encode as JPEG data URL. Quality is 0-1. */
-  toDataURL(mimeType: 'image/jpeg', quality?: number): string
-  /** Async: encode as data URL via callback. */
-  toDataURL(cb: (err: Error | null, result: string) => void): void
-  toDataURL(mimeType: 'image/png', cb: (err: Error | null, result: string) => void): void
-  toDataURL(mimeType: 'image/jpeg', cb: (err: Error | null, result: string) => void): void
-  toDataURL(mimeType: 'image/jpeg', quality: number, cb: (err: Error | null, result: string) => void): void
-}
-
-// ---------------------------------------------------------------------------
-// Stream classes
-// ---------------------------------------------------------------------------
-
-/** Readable stream that emits PNG-encoded data. */
-export class PNGStream extends Readable {}
-
-/** Readable stream that emits JPEG-encoded data. */
-export class JPEGStream extends Readable {}
-
-// ---------------------------------------------------------------------------
-// Factory functions
-// ---------------------------------------------------------------------------
-
-/**
- * Create a new canvas with node-canvas compatible API.
- * Canvas instances created through this function have `createPNGStream()`,
- * `createJPEGStream()`, and node-canvas compatible `toBuffer()` overloads.
- *
- * When `type` is `'svg'`, returns a `SvgCanvas` which produces vector output
- * via `getContent()` instead of raster encoding methods.
- *
- * @param width  Canvas width in pixels
- * @param height Canvas height in pixels
- * @param type   Canvas type: 'image' (default) or 'svg'
- */
-export function createCanvas(width: number, height: number, type: 'svg'): SvgCanvas
-export function createCanvas(width: number, height: number, type?: 'image'): Canvas
-
-/**
- * Create an ImageData instance.
- * @param data   Pixel data array
- * @param width  Width in pixels
- * @param height Height in pixels (calculated from data length if omitted)
- */
-export function createImageData(data: Uint8ClampedArray, width: number, height?: number): NapiImageData
-export function createImageData(width: number, height: number): NapiImageData
-
-/**
- * Load an image from a file path, URL, Buffer, or other source.
- * Returns a Promise that resolves to an Image instance.
- */
-export function loadImage(
-  source: string | URL | Buffer | ArrayBufferLike | Uint8Array | NapiImage | import('stream').Readable,
-  options?: { alt?: string; maxRedirects?: number; requestOptions?: import('http').RequestOptions },
-): Promise<NapiImage>
-
-// ---------------------------------------------------------------------------
-// Font registration (node-canvas convention)
-// ---------------------------------------------------------------------------
-
-/**
- * Register a font file for use in canvas text rendering.
- * Compatible with node-canvas's `registerFont()`.
- *
- * Note: @napi-rs/canvas auto-detects weight and style from font file metadata
- * (matching browser behavior). The `weight` and `style` properties in fontFace
- * are accepted for API compatibility.
- *
- * @param path     Absolute path to the font file (.ttf, .otf, etc.)
- * @param fontFace Font face properties matching CSS @font-face descriptors
- */
-export function registerFont(path: string, fontFace: { family: string; weight?: string; style?: string }): void
-
-/**
- * Deregister all previously registered fonts.
- * Compatible with node-canvas's `deregisterAllFonts()`.
- */
-export function deregisterAllFonts(): void
-
-// ---------------------------------------------------------------------------
-// Re-exported classes & values
-// ---------------------------------------------------------------------------
-
-// Canvas is exported both as a type (the compat interface above) and as a
-// value (constructor that returns compat Canvas instances at runtime).
-export declare const Canvas: {
-  new (width: number, height: number): Canvas
-  new (width: number, height: number, flag: SvgExportFlag): SvgCanvas
-  prototype: NapiCanvas
-}
-
-export { NapiImage as Image }
-export { NapiImageData as ImageData }
-export { NapiPath2D as Path2D }
-export { NapiDOMPoint as DOMPoint }
-export { NapiDOMMatrix as DOMMatrix }
-export { NapiDOMRect as DOMRect }
-
-// SKRSContext2D is an interface in index.d.ts but a class value at runtime.
-// Declare as const to export the value for instanceof checks and re-export the type.
-export type CanvasRenderingContext2D = SKRSContext2D
-export declare const CanvasRenderingContext2D: { prototype: SKRSContext2D }
-/** Legacy alias for CanvasRenderingContext2D. */
-export type Context2d = SKRSContext2D
-export declare const Context2d: { prototype: SKRSContext2D }
-
-// ---------------------------------------------------------------------------
-// @napi-rs/canvas extras (not part of node-canvas, but useful)
-// ---------------------------------------------------------------------------
-
-export { IGlobalFonts }
-export declare const GlobalFonts: IGlobalFonts & {
-  /** Reload system fonts. Available at runtime but not declared in IGlobalFonts. */
-  loadSystemFonts(): number
-}
-export { PDFDocument }
-export { NapiCanvas as CanvasElement }
-export { SvgCanvas as SVGCanvas }