pixel-data-js 0.15.0 → 0.16.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixel-data-js",
   "type": "module",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "packageManager": "pnpm@10.30.0",
   "description": "JS Pixel and ImageData operations",
   "author": {

package/src/BlendModes/BlendModeRegistry.ts

@@ -0,0 +1,78 @@
+import type { BlendColor32 } from '../_types'
+
+export type BlendModeRegistry = ReturnType<typeof makeBlendModeRegistry>
+
+export function makeBlendModeRegistry<
+  BlendModes extends Record<string, number>,
+  Name extends keyof BlendModes = keyof BlendModes,
+  Index extends BlendModes[Name] = BlendModes[Name]
+>(
+  blendModes: BlendModes,
+  initialEntries: Record<Index, BlendColor32>,
+) {
+
+  const modes: BlendColor32[] = []
+  const toIndex = new Map<BlendColor32, Index>()
+  const fromIndex = new Map<Index, BlendColor32>()
+  const byName = {} as Record<Name, BlendColor32>
+
+  const add = (name: Name, index: Index, blendFn: BlendColor32) => {
+    if (modes[index]) {
+      throw new Error(`Blend Mode index: ${index} is already used`)
+    }
+
+    if (byName[name]) {
+      throw new Error(`Blend Mode name: "${name as string}" is already used`)
+    }
+
+    const idx = index
+    modes[idx] = blendFn
+    toIndex.set(blendFn, idx)
+    fromIndex.set(idx, blendFn)
+    ;(byName as any)[name] = blendFn
+  }
+
+  for (const [name, index] of Object.entries(blendModes)) {
+    const blend = initialEntries[index as Index]
+    add(name as Name, index as Index, blend)
+  }
+
+  return {
+    modes,
+    byName,
+    toIndex,
+    fromIndex,
+    add,
+    indexType: null as unknown as Index,
+    nameType: null as unknown as Name
+  }
+}
+
+/**
+ * @internal
+ */
+export interface BaseBlendModeRegistry {
+  overwrite: BlendColor32
+  sourceOver: BlendColor32
+  darken: BlendColor32
+  multiply: BlendColor32
+  colorBurn: BlendColor32
+  linearBurn: BlendColor32
+  darkerColor: BlendColor32
+  lighten: BlendColor32
+  screen: BlendColor32
+  colorDodge: BlendColor32
+  linearDodge: BlendColor32
+  lighterColor: BlendColor32
+  overlay: BlendColor32
+  softLight: BlendColor32
+  hardLight: BlendColor32
+  vividLight: BlendColor32
+  linearLight: BlendColor32
+  pinLight: BlendColor32
+  hardMix: BlendColor32
+  difference: BlendColor32
+  exclusion: BlendColor32
+  subtract: BlendColor32
+  divide: BlendColor32
+}

package/src/BlendModes/blend-modes-fast.ts

@@ -1,6 +1,6 @@
 import type { BlendColor32, Color32 } from '../_types'
-import type { BaseBlendToIndexGetter, BaseIndexToBlendGetter } from './blend-mode-getters'
-import { BlendMode, type BlendModeIndex, overwriteBase } from './blend-modes'
+import { BaseBlendMode, overwriteBase } from './blend-modes'
+import { makeBlendModeRegistry } from './BlendModeRegistry'
 
 export const overwriteFast = overwriteBase
 
@@ -575,88 +575,35 @@ export const divideFast: BlendColor32 = (src, dst) => {
   return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
 }
 
-export const FAST_BLENDER_REGISTRY = [
-  [BlendMode.overwrite, overwriteFast],
-  [BlendMode.sourceOver, sourceOverFast],
-
-  [BlendMode.darken, darkenFast],
-  [BlendMode.multiply, multiplyFast],
-  [BlendMode.colorBurn, colorBurnFast],
-  [BlendMode.linearBurn, linearBurnFast],
-  [BlendMode.darkerColor, darkerFast],
-
-  [BlendMode.lighten, lightenFast],
-  [BlendMode.screen, screenFast],
-  [BlendMode.colorDodge, colorDodgeFast],
-  [BlendMode.linearDodge, linearDodgeFast],
-  [BlendMode.lighterColor, lighterFast],
-
-  [BlendMode.overlay, overlayFast],
-  [BlendMode.softLight, softLightFast],
-  [BlendMode.hardLight, hardLightFast],
-  [BlendMode.vividLight, vividLightFast],
-  [BlendMode.linearLight, linearLightFast],
-  [BlendMode.pinLight, pinLightFast],
-  [BlendMode.hardMix, hardMixFast],
-
-  [BlendMode.difference, differenceFast],
-  [BlendMode.exclusion, exclusionFast],
-  [BlendMode.subtract, subtractFast],
-  [BlendMode.divide, divideFast],
-] as const
-
-export type RegisteredFastBlender = typeof FAST_BLENDER_REGISTRY[number][1]
-
-export const FAST_BLEND_MODES: BlendColor32[] = []
-
-for (const [index, blend] of FAST_BLENDER_REGISTRY) {
-  FAST_BLEND_MODES[index as BlendModeIndex] = blend
+export const BASE_FAST_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32> = {
+  [BaseBlendMode.overwrite]: overwriteFast,
+  [BaseBlendMode.sourceOver]: sourceOverFast,
+  [BaseBlendMode.darken]: darkenFast,
+  [BaseBlendMode.multiply]: multiplyFast,
+  [BaseBlendMode.colorBurn]: colorBurnFast,
+  [BaseBlendMode.linearBurn]: linearBurnFast,
+  [BaseBlendMode.darkerColor]: darkerFast,
+
+  [BaseBlendMode.lighten]: lightenFast,
+  [BaseBlendMode.screen]: screenFast,
+  [BaseBlendMode.colorDodge]: colorDodgeFast,
+  [BaseBlendMode.linearDodge]: linearDodgeFast,
+  [BaseBlendMode.lighterColor]: lighterFast,
+
+  [BaseBlendMode.overlay]: overlayFast,
+  [BaseBlendMode.softLight]: softLightFast,
+  [BaseBlendMode.hardLight]: hardLightFast,
+  [BaseBlendMode.vividLight]: vividLightFast,
+  [BaseBlendMode.linearLight]: linearLightFast,
+  [BaseBlendMode.pinLight]: pinLightFast,
+  [BaseBlendMode.hardMix]: hardMixFast,
+
+  [BaseBlendMode.difference]: differenceFast,
+  [BaseBlendMode.exclusion]: exclusionFast,
+  [BaseBlendMode.subtract]: subtractFast,
+  [BaseBlendMode.divide]: divideFast,
 }
 
-export const FAST_BLEND_TO_INDEX = new Map<RegisteredFastBlender, BlendModeIndex>(
-  FAST_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      entry[1],
-      index as BlendModeIndex,
-    ]
-  }),
-) as BaseBlendToIndexGetter<RegisteredFastBlender>
-
-export const INDEX_TO_FAST_BLEND = new Map<BlendModeIndex, RegisteredFastBlender>(
-  FAST_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      index as BlendModeIndex,
-      entry[1],
-    ]
-  }),
-) as BaseIndexToBlendGetter<RegisteredFastBlender>
-
-export type FastBlendModes = {
-  [K in keyof typeof BlendMode]: RegisteredFastBlender
+export function makeFastBlendModeRegistry() {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_FAST_BLEND_MODE_FUNCTIONS)
 }
-
-export const FAST_BLEND_MODE_BY_NAME: FastBlendModes = {
-  overwrite: overwriteFast,
-  sourceOver: sourceOverFast,
-  darken: darkenFast,
-  multiply: multiplyFast,
-  colorBurn: colorBurnFast,
-  linearBurn: linearBurnFast,
-  darkerColor: darkerFast,
-  lighten: lightenFast,
-  screen: screenFast,
-  colorDodge: colorDodgeFast,
-  linearDodge: linearDodgeFast,
-  lighterColor: lighterFast,
-  overlay: overlayFast,
-  softLight: softLightFast,
-  hardLight: hardLightFast,
-  vividLight: vividLightFast,
-  linearLight: linearLightFast,
-  pinLight: pinLightFast,
-  hardMix: hardMixFast,
-  difference: differenceFast,
-  exclusion: exclusionFast,
-  subtract: subtractFast,
-  divide: divideFast,
-} as const

package/src/BlendModes/blend-modes-perfect.ts

@@ -1,6 +1,6 @@
 import type { BlendColor32, Color32 } from '../_types'
-import type { BaseBlendToIndexGetter, BaseIndexToBlendGetter } from './blend-mode-getters'
-import { BlendMode, type BlendModeIndex, overwriteBase } from './blend-modes'
+import { BaseBlendMode, overwriteBase } from './blend-modes'
+import { type BaseBlendModeRegistry, makeBlendModeRegistry } from './BlendModeRegistry'
 
 export const overwritePerfect = overwriteBase
 
@@ -565,87 +565,38 @@ export const dividePerfect: BlendColor32 = (src, dst) => {
   return ((a << 24) | (b << 16) | (g << 8) | r) >>> 0 as Color32
 }
 
-export const PERFECT_BLENDER_REGISTRY = [
-  [BlendMode.overwrite, overwritePerfect],
-  [BlendMode.sourceOver, sourceOverPerfect],
-
-  [BlendMode.darken, darkenPerfect],
-  [BlendMode.multiply, multiplyPerfect],
-  [BlendMode.colorBurn, colorBurnPerfect],
-  [BlendMode.linearBurn, linearBurnPerfect],
-  [BlendMode.darkerColor, darkerPerfect],
-
-  [BlendMode.lighten, lightenPerfect],
-  [BlendMode.screen, screenPerfect],
-  [BlendMode.colorDodge, colorDodgePerfect],
-  [BlendMode.linearDodge, linearDodgePerfect],
-  [BlendMode.lighterColor, lighterPerfect],
-
-  [BlendMode.overlay, overlayPerfect],
-  [BlendMode.softLight, softLightPerfect],
-  [BlendMode.hardLight, hardLightPerfect],
-  [BlendMode.vividLight, vividLightPerfect],
-  [BlendMode.linearLight, linearLightPerfect],
-  [BlendMode.pinLight, pinLightPerfect],
-  [BlendMode.hardMix, hardMixPerfect],
-
-  [BlendMode.difference, differencePerfect],
-  [BlendMode.exclusion, exclusionPerfect],
-  [BlendMode.subtract, subtractPerfect],
-  [BlendMode.divide, dividePerfect],
-] as const
-
-export type RegisteredPerfectBlender = typeof PERFECT_BLENDER_REGISTRY[number][1]
-
-export const PERFECT_BLEND_MODES: BlendColor32[] = []
-for (const [index, blend] of PERFECT_BLENDER_REGISTRY) {
-  PERFECT_BLEND_MODES[index as BlendModeIndex] = blend
+export interface PerfectBlendModes extends BaseBlendModeRegistry {
 }
 
-export const PERFECT_BLEND_TO_INDEX = new Map(
-  PERFECT_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      entry[1],
-      index as BlendModeIndex,
-    ]
-  }),
-) as BaseBlendToIndexGetter<RegisteredPerfectBlender>
-
-export const INDEX_TO_PERFECT_BLEND = new Map(
-  PERFECT_BLENDER_REGISTRY.map((entry, index) => {
-    return [
-      index as BlendModeIndex,
-      entry[1],
-    ]
-  }),
-) as BaseIndexToBlendGetter<RegisteredPerfectBlender>
-
-export type PerfectBlendModes = {
-  [K in keyof typeof BlendMode]: RegisteredPerfectBlender
+export const BASE_PERFECT_BLEND_MODE_FUNCTIONS: Record<number, BlendColor32> = {
+  [BaseBlendMode.overwrite]: overwritePerfect,
+  [BaseBlendMode.sourceOver]: sourceOverPerfect,
+  [BaseBlendMode.darken]: darkenPerfect,
+  [BaseBlendMode.multiply]: multiplyPerfect,
+  [BaseBlendMode.colorBurn]: colorBurnPerfect,
+  [BaseBlendMode.linearBurn]: linearBurnPerfect,
+  [BaseBlendMode.darkerColor]: darkerPerfect,
+
+  [BaseBlendMode.lighten]: lightenPerfect,
+  [BaseBlendMode.screen]: screenPerfect,
+  [BaseBlendMode.colorDodge]: colorDodgePerfect,
+  [BaseBlendMode.linearDodge]: linearDodgePerfect,
+  [BaseBlendMode.lighterColor]: lighterPerfect,
+
+  [BaseBlendMode.overlay]: overlayPerfect,
+  [BaseBlendMode.softLight]: softLightPerfect,
+  [BaseBlendMode.hardLight]: hardLightPerfect,
+  [BaseBlendMode.vividLight]: vividLightPerfect,
+  [BaseBlendMode.linearLight]: linearLightPerfect,
+  [BaseBlendMode.pinLight]: pinLightPerfect,
+  [BaseBlendMode.hardMix]: hardMixPerfect,
+
+  [BaseBlendMode.difference]: differencePerfect,
+  [BaseBlendMode.exclusion]: exclusionPerfect,
+  [BaseBlendMode.subtract]: subtractPerfect,
+  [BaseBlendMode.divide]: dividePerfect,
 }
 
-export const PERFECT_BLEND_MODE_BY_NAME: PerfectBlendModes = {
-  overwrite: overwritePerfect,
-  sourceOver: sourceOverPerfect,
-  darken: darkenPerfect,
-  multiply: multiplyPerfect,
-  colorBurn: colorBurnPerfect,
-  linearBurn: linearBurnPerfect,
-  darkerColor: darkerPerfect,
-  lighten: lightenPerfect,
-  screen: screenPerfect,
-  colorDodge: colorDodgePerfect,
-  linearDodge: linearDodgePerfect,
-  lighterColor: lighterPerfect,
-  overlay: overlayPerfect,
-  softLight: softLightPerfect,
-  hardLight: hardLightPerfect,
-  vividLight: vividLightPerfect,
-  linearLight: linearLightPerfect,
-  pinLight: pinLightPerfect,
-  hardMix: hardMixPerfect,
-  difference: differencePerfect,
-  exclusion: exclusionPerfect,
-  subtract: subtractPerfect,
-  divide: dividePerfect,
-} as const
+export function makePerfectBlendModeRegistry() {
+  return makeBlendModeRegistry(BaseBlendMode, BASE_PERFECT_BLEND_MODE_FUNCTIONS)
+}

package/src/BlendModes/blend-modes.ts

@@ -1,38 +1,30 @@
-// The enum index IS the permanent ID.
-// do not change the order, Adding to it is ok.
 import type { BlendColor32 } from '../_types'
 
-export enum BlendMode {
-  overwrite,
-  sourceOver,
-
-  darken,
-  multiply,
-  colorBurn,
-  linearBurn,
-  darkerColor,
-
-  lighten,
-  screen,
-  colorDodge,
-  linearDodge,
-  lighterColor,
-
-  overlay,
-  softLight,
-  hardLight,
-  vividLight,
-  linearLight,
-  pinLight,
-  hardMix,
-
-  difference,
-  exclusion,
-  subtract,
-  divide,
-}
-
-export type BlendModeIndex = typeof BlendMode[keyof typeof BlendMode];
+export const BaseBlendMode = {
+  overwrite: 0,
+  sourceOver: 1,
+  darken: 2,
+  multiply: 3,
+  colorBurn: 4,
+  linearBurn: 5,
+  darkerColor: 6,
+  lighten: 7,
+  screen: 8,
+  colorDodge: 9,
+  linearDodge: 10,
+  lighterColor: 11,
+  overlay: 12,
+  softLight: 13,
+  hardLight: 14,
+  vividLight: 15,
+  linearLight: 16,
+  pinLight: 17,
+  hardMix: 18,
+  difference: 19,
+  exclusion: 20,
+  subtract: 21,
+  divide: 22,
+} as const
 
 export const overwriteBase: BlendColor32 = (src, _dst) => src
 overwriteBase.isOverwrite = true

package/src/PixelData/blendPixelData.ts

@@ -1,6 +1,5 @@
 import { type Color32, MaskType, type PixelBlendOptions } from '../_types'
-import { BlendMode } from '../BlendModes/blend-modes'
-import { FAST_BLEND_MODES } from '../BlendModes/blend-modes-fast'
+import { sourceOverFast } from '../BlendModes/blend-modes-fast'
 import type { PixelData } from './PixelData'
 
 /**
@@ -30,7 +29,7 @@ export function blendPixelData(
     w: width = src.width,
     h: height = src.height,
     alpha: globalAlpha = 255,
-    blendFn = FAST_BLEND_MODES[BlendMode.sourceOver],
+    blendFn = sourceOverFast,
     mask,
     maskType = MaskType.ALPHA,
     mw,

package/src/PixelData/extractPixelData.ts

@@ -0,0 +1,28 @@
+import type { Rect } from '../_types'
+import { extractPixelDataBuffer } from './extractPixelDataBuffer'
+import { PixelData } from './PixelData'
+
+/**
+ * High-level extraction that returns a new PixelData instance.
+ * Leverages extractPixelDataBuffer for optimized 32-bit memory moves.
+ */
+export function extractPixelData(source: PixelData, rect: Rect): PixelData
+export function extractPixelData(source: PixelData, x: number, y: number, w: number, h: number): PixelData
+export function extractPixelData(
+  source: PixelData,
+  _x: Rect | number,
+  _y?: number,
+  _w?: number,
+  _h?: number,
+): PixelData {
+  const { x, y, w, h } = typeof _x === 'object'
+    ? _x
+    : { x: _x, y: _y!, w: _w!, h: _h! }
+
+  const result = new PixelData(new ImageData(w, h))
+
+  const buffer = extractPixelDataBuffer(source, x, y, w, h)
+  result.data32.set(buffer)
+
+  return result
+}

package/src/index.ts

@@ -3,15 +3,8 @@ export * from './color'
 
 export * from './Algorithm/floodFillSelection'
 
-export {
-  BlendMode,
-  type BlendModeIndex,
-} from './BlendModes/blend-modes'
-export {
-  type BlendToIndexGetter,
-  type IndexToBlendGetter,
-} from './BlendModes/blend-mode-getters'
-
+export * from './BlendModes/BlendModeRegistry'
+export * from './BlendModes/blend-modes'
 export * from './BlendModes/blend-modes-fast'
 export * from './BlendModes/blend-modes-perfect'
 
@@ -57,6 +50,7 @@ export * from './PixelData/applyMaskToPixelData'
 export * from './PixelData/blendColorPixelData'
 export * from './PixelData/blendPixelData'
 export * from './PixelData/clearPixelData'
+export * from './PixelData/extractPixelData'
 export * from './PixelData/extractPixelDataBuffer'
 export * from './PixelData/fillPixelData'
 export * from './PixelData/invertPixelData'

package/src/BlendModes/blend-mode-getters.ts

@@ -1,14 +0,0 @@
-import type { BlendColor32 } from '../_types'
-import type { BlendModeIndex } from './blend-modes'
-import { FAST_BLEND_TO_INDEX, INDEX_TO_FAST_BLEND } from './blend-modes-fast'
-import { type INDEX_TO_PERFECT_BLEND, PERFECT_BLEND_TO_INDEX } from './blend-modes-perfect'
-
-export type BaseIndexToBlendGetter<B extends BlendColor32> = {
-  get: (index: BlendModeIndex) => B
-}
-export type IndexToBlendGetter = typeof INDEX_TO_FAST_BLEND | typeof INDEX_TO_PERFECT_BLEND
-
-export type BaseBlendToIndexGetter<B extends BlendColor32> = {
-  get: (blend: B) => BlendModeIndex
-}
-export type BlendToIndexGetter = typeof FAST_BLEND_TO_INDEX | typeof PERFECT_BLEND_TO_INDEX