@livechart/sharp-vibrant 0.1.0 → 0.2.1

package/src/index.ts

@@ -3,4 +3,4 @@ import SharpImage from './image/sharp';
 
 Vibrant.DefaultOpts.ImageClass = SharpImage;
 
-export = Vibrant;
+export default Vibrant;

package/src/test/common/data.ts

@@ -1,4 +1,5 @@
 import path from 'path';
+import sharp from 'sharp';
 
 import { Sample } from '../../../fixtures/sample/types'
 export const SNAPSHOT: Sample[] = require('../../../fixtures/sample/images/palettes.json')
@@ -7,9 +8,10 @@ export interface TestSample extends Sample {
   relativeUrl: string
 }
 
-export type SamplePathKey = Exclude<keyof TestSample, 'palettes'>
+export type SamplePathKey = Exclude<keyof TestSample, 'palettes' | 'dimensions'>
 
 export const SAMPLES: TestSample[] = SNAPSHOT.map((s) => Object.assign(s, {
+  sharp: sharp(path.join(__dirname, '../../../fixtures/sample/images/', s.name)),
   filePath: path.join(__dirname, '../../../fixtures/sample/images/', s.name),
   relativeUrl: `base/fixtures/sample/images/${s.name}`
 }))

package/src/test/common/helper.ts

@@ -1,25 +1,32 @@
 /* eslint-env mocha */
 import { expect } from 'chai'
-import { VibrantStatic } from '../../typing'
+import type { PaletteResult, VibrantStatic, ImageDimensions } from '../../typing'
 import Builder from '../../builder'
 import { Palette, Swatch } from '../../color'
 import util = require('../../util')
-import {
+import type {
   TestSample, SamplePathKey
 } from './data'
 
 import { table, getBorderCharacters } from 'table'
 
+type Env = 'node'
 
 const TABLE_OPTS = {
   border: getBorderCharacters('void')
 }
 
-
 const displayColorDiffTable = (diff: string[][]) => {
   console.log(table(diff, TABLE_OPTS))
 }
 
+const assertDimensions = (reference: ImageDimensions, dimensions: ImageDimensions) => {
+  expect(dimensions, 'dimensions should be returned').not.to.be.null
+
+  expect(dimensions.width, `width is not correct`).to.eq(reference.width)
+  expect(dimensions.height, `height is not correct`).to.eq(reference.height)
+}
+
 const assertPalette = (reference: Palette, palette: Palette) => {
   expect(palette, 'palette should be returned').not.to.be.null
 
@@ -32,7 +39,7 @@ const assertPalette = (reference: Palette, palette: Palette) => {
 
     if (expected === null) {
       if (actual !== null) {
-        console.warn(`WARN: ${name} color was not expected. Got ${actual.getHex()}`)
+        console.warn(`WARN: ${name} color was not expected. Got ${actual.hex}`)
       }
     } else {
       expect(actual, `${name} color was expected`).not.to.be.null
@@ -68,37 +75,50 @@ const assertPalette = (reference: Palette, palette: Palette) => {
     .to.equal(0)
 }
 
-const paletteCallback = (references: any, sample: TestSample, done: Mocha.Done) =>
-  (err?: Error, palette?: Palette) => {
+function assertResult(env: Env, sample: TestSample, result: PaletteResult) {
+  assertDimensions(sample.dimensions, result.imageDimensions)
+  assertPalette(sample.palettes[env], result.palette)
+}
+
+const paletteCallback = (env: Env, sample: TestSample, done: Mocha.Done) =>
+  (err?: Error, result?: PaletteResult) => {
     setTimeout(() => {
 
       expect(err, `should not throw error '${err}'`).to.be.null
-      assertPalette(references, palette!)
+      assertResult(env, sample, result!)
 
       done()
     }, 0)
   }
 
-export const testVibrant = (Vibrant: VibrantStatic, sample: TestSample, pathKey: SamplePathKey, env: 'node', builderCallback: (b: Builder) => Builder = null!) => {
-  return (done: Mocha.Done) => {
-    let builder = Vibrant.from(sample[pathKey])
-      .quality(1)
-
-    if (typeof builderCallback === 'function') builder = builderCallback(builder)
-
-    builder.getPalette(paletteCallback(sample.palettes[env], sample, done))
+export const testVibrant = (
+  Vibrant: VibrantStatic,
+  sample: TestSample,
+  pathKey: SamplePathKey,
+  env: Env,
+  builderCallback: (b: Builder) => Builder = null!
+) => (done: Mocha.Done) => {
+  let builder = Vibrant.from(sample[pathKey]).quality(1)
+
+  if (typeof builderCallback === 'function') {
+    builder = builderCallback(builder)
   }
-}
 
+  builder.getPalette(paletteCallback(env, sample, done))
+}
 
-export const testVibrantAsPromised = (Vibrant: VibrantStatic, sample: TestSample, pathKey: SamplePathKey, env: 'node', builderCallback: (b: Builder) => Builder = null!) => {
+export const testVibrantAsPromised = (
+  Vibrant: VibrantStatic,
+  sample: TestSample,
+  pathKey: SamplePathKey,
+  env: Env,
+  builderCallback: (b: Builder) => Builder = null!
+) => {
   return () => {
-    let builder = Vibrant.from(sample[pathKey])
-      .quality(1)
+    let builder = Vibrant.from(sample[pathKey]).quality(1)
 
     if (typeof builderCallback === 'function') builder = builderCallback(builder)
 
-    return builder.getPalette()
-      .then(palette => assertPalette(sample.palettes[env], palette))
+    return builder.getPalette().then(result => assertResult(env, sample, result))
   }
 }

package/src/test/vibrant.spec.ts

@@ -12,8 +12,10 @@ import Vibrant = require('../')
 describe('Palette Extraction', () => {
   describe('process samples', () =>
     SAMPLES.forEach((sample) => {
-      it(`${sample.name} (callback)`, testVibrant(Vibrant, sample, 'filePath', 'node'))
-      it(`${sample.name} (Promise)`, testVibrantAsPromised(Vibrant, sample, 'filePath', 'node'))
+      it(`${sample.name} via sharp (callback)`, testVibrant(Vibrant, sample, 'sharp', 'node'))
+      it(`${sample.name} via sharp (Promise)`, testVibrantAsPromised(Vibrant, sample, 'sharp', 'node'))
+      it(`${sample.name} via file path (callback)`, testVibrant(Vibrant, sample, 'filePath', 'node'))
+      it(`${sample.name} via file path (Promise)`, testVibrantAsPromised(Vibrant, sample, 'filePath', 'node'))
     })
   )
 })

package/src/typing.ts

@@ -1,5 +1,6 @@
 import type { Palette, Swatch } from './color';
 import type Builder from './builder';
+import { type Sharp } from 'sharp';
 
 export interface VibrantStatic {
   from(src: ImageSource): Builder
@@ -11,17 +12,28 @@ export interface Callback<T> {
 
 export type ImageCallback = Callback<Image>;
 
-export type ImageSource = string | Buffer;
+export type ImageSource = string | Buffer | Sharp;
 
-export type Pixels = Uint8ClampedArray | Buffer;
-export interface ImageData {
-  data: Pixels,
-  width: number,
-  height: number
+export interface ImageDimensions {
+  readonly width: number
+  readonly height: number
 }
 
-export interface Image {
+export interface ImagePixelInfo {
   readonly pixelCount: number
+}
+
+export type Pixels = Uint8ClampedArray | Buffer;
+export interface ImageData extends ImageDimensions {
+  data: Pixels
+}
+
+export interface PaletteResult extends ImagePixelInfo {
+  readonly imageDimensions: ImageDimensions
+  readonly palette: Palette
+}
+
+export interface Image extends ImageDimensions, ImagePixelInfo {
   readonly imageData: ImageData
 
   load(image: ImageSource, opts: ComputedOptions): Promise<Image>

package/src/vibrant.ts

@@ -4,6 +4,7 @@ import type {
   Options,
   ComputedOptions,
   Callback,
+  PaletteResult,
 } from './typing';
 
 import { Palette, Swatch } from './color';
@@ -46,8 +47,6 @@ class Vibrant {
 
   opts: ComputedOptions;
 
-  #palette: Palette | null = null;
-
   #src: ImageSource;
 
   constructor(src: ImageSource, opts?: Partial<Options>) {
@@ -65,23 +64,30 @@ class Vibrant {
       .then((colors) => Promise.resolve(generator!(colors)));
   }
 
-  palette(): Palette | null {
-    return this.#palette;
-  }
-
-  getPalette(cb?: Callback<Palette>): Promise<Palette> {
+  getPalette(cb?: Callback<PaletteResult>): Promise<PaletteResult> {
     const image = new this.opts.ImageClass();
     const result = image.load(this.#src, this.opts)
       .then((loadedImage) => this.process(loadedImage))
       .then((palette) => {
-        this.#palette = palette;
+        const paletteResult: PaletteResult = {
+          pixelCount: image.pixelCount,
+          imageDimensions: {
+            width: image.width,
+            height: image.height,
+          },
+          palette,
+        };
         image.cleanup();
-        return palette;
+        return paletteResult;
       }, (err) => {
         image.cleanup();
         throw err;
       });
-    if (cb) result.then((palette) => cb(null!, palette), (err) => cb(err));
+
+    if (cb) {
+      result.then((palette) => cb(null!, palette), (err) => cb(err));
+    }
+
     return result;
   }
 }

package/tsconfig.json

@@ -10,12 +10,12 @@
     "lib": [
       "es6"
     ],
-    "module": "commonjs",
-    "moduleResolution": "node",
+    "module": "es2022",
+    "moduleResolution": "bundler",
     "strict": true,
+    "rootDir": "./src",
     "outDir": "lib",
-    "baseUrl": "./src",
-    "sourceMap": true,
+    "sourceMap": true
   },
   "include": [
     "./src"
@@ -23,15 +23,5 @@
   "exclude": [
     "./src/test"
   ],
-  "import/resolver": {
-    "node": {
-      "extensions": [
-        ".js",
-        ".jsx",
-        ".ts",
-        ".tsx"
-      ]
-    }
-  },
   "compileOnSave": false
 }