gb-image-decoder 1.3.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.cts CHANGED
@@ -28,27 +28,11 @@ declare enum ExportFrameMode {
28
28
  FRAMEMODE_SQUARE_BLACK = "square_black",
29
29
  FRAMEMODE_SQUARE_WHITE = "square_white"
30
30
  }
31
+ declare const channels: ChannelKey[];
31
32
 
32
- interface Channel<DecoderType> {
33
- key: ChannelKey;
34
- tiles?: string[];
35
- decoder: DecoderType;
36
- canvas: HTMLCanvasElement;
37
- }
38
33
  type RGBNTiles = Partial<Record<ChannelKey, string[]>>;
39
- type Channels<DecoderType> = Record<ChannelKey, Channel<DecoderType>>;
40
34
  type SourceCanvases = Partial<Record<ChannelKey, HTMLCanvasElement>>;
41
35
  type CanvasCreator = () => HTMLCanvasElement;
42
- type ImageDataCreator = (rawImageData: Uint8ClampedArray, width: number, height: number) => ImageData;
43
- interface ChangedTile {
44
- index: number;
45
- newTile: string;
46
- }
47
- interface ScaledCanvasSize {
48
- initialHeight: number;
49
- initialWidth: number;
50
- tilesPerLine: number;
51
- }
52
36
  interface RGBValue {
53
37
  r: number;
54
38
  g: number;
@@ -63,92 +47,87 @@ interface RGBNPalette {
63
47
  n?: number[];
64
48
  blend?: BlendMode;
65
49
  }
66
- interface DecoderOptions {
50
+ interface BaseImageCreationParams<TilesType> {
51
+ tiles: TilesType;
52
+ imageStartLine?: number;
67
53
  tilesPerLine?: number;
68
- canvasCreator?: CanvasCreator;
69
- imageDataCreator?: ImageDataCreator;
54
+ scaleFactor?: number;
55
+ handleExportFrame?: ExportFrameMode;
70
56
  }
71
- interface DecoderUpdateParams {
72
- canvas: HTMLCanvasElement | null;
73
- tiles: string[];
74
- palette: string[];
75
- framePalette: string[];
76
- imageStartLine?: number;
57
+ interface MonochromeImageCreationParams extends BaseImageCreationParams<string[]> {
58
+ imagePalette: BWPalette;
59
+ framePalette?: BWPalette;
77
60
  }
78
- interface RGBNDecoderUpdateParams {
79
- canvas: HTMLCanvasElement | null;
80
- tiles: RGBNTiles;
61
+ type FullMonochromeImageCreationParams = Required<MonochromeImageCreationParams>;
62
+ interface RGBNImageCreationParams extends BaseImageCreationParams<RGBNTiles> {
81
63
  palette: RGBNPalette;
82
64
  lockFrame?: boolean;
83
65
  }
84
-
85
- declare class Decoder {
86
- private canvas;
87
- private tiles;
88
- private colors;
89
- private frameColors;
90
- private rawImageData;
91
- private lockFrame;
92
- private colorData;
93
- private frameColorData;
94
- private tilesPerLine;
95
- private imageStartLine;
96
- private canvasCreator;
97
- private imageDataCreator;
98
- constructor(options?: DecoderOptions);
99
- update({ canvas, tiles, palette, framePalette, imageStartLine, }: DecoderUpdateParams): void;
100
- private setImageStartLine;
101
- private updateCanvas;
102
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
103
- private getScaledCanvasSize;
104
- private getExportTiles;
105
- private setCanvas;
106
- private setPalettes;
107
- private setTiles;
108
- private renderTile;
109
- private paintTile;
110
- private paintTileScaled;
111
- private getHeight;
112
- private getWidth;
66
+ type FullRGBNImageCreationParams = Required<RGBNImageCreationParams>;
67
+ interface PixelDimensions {
68
+ width: number;
69
+ height: number;
113
70
  }
71
+ interface BaseImageContext {
72
+ tilesPerLine: number;
73
+ imageStartLine: number;
74
+ handleExportFrame: ExportFrameMode;
75
+ }
76
+ interface MonochromeImageContext extends BaseImageContext {
77
+ imagePalette: BWPalette;
78
+ framePalette: BWPalette;
79
+ }
80
+ interface CropResult<ContextType> {
81
+ tiles: string[];
82
+ dimensions: PixelDimensions;
83
+ contextUpdates: Partial<ContextType>;
84
+ }
85
+ interface RawOutput {
86
+ data: Uint8ClampedArray;
87
+ dimensions: PixelDimensions;
88
+ }
89
+
90
+ declare const getDimensions: (tilesLength: number, tilesPerLine: number) => PixelDimensions;
91
+ declare const scaleRawImageData: (data: Uint8ClampedArray, width: number, height: number, scale: number) => RawOutput;
92
+ declare const getRawMonochromeImageData: (params: FullMonochromeImageCreationParams) => RawOutput;
93
+ declare const getMonochromeImageUrl: (params: MonochromeImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
94
+
95
+ declare const getRawRGBNImageData: (params: FullRGBNImageCreationParams, canvasCreator: CanvasCreator) => RawOutput;
96
+ declare const getRGBNImageUrl: (params: RGBNImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
114
97
 
115
- declare class RGBNDecoder {
116
- private canvas;
117
- private palette;
118
- private lockFrame;
119
- private channels;
120
- private tilesPerLine;
121
- private canvasCreator;
122
- private imageDataCreator;
123
- constructor(options?: DecoderOptions);
124
- update({ canvas, tiles, palette, lockFrame, }: RGBNDecoderUpdateParams): void;
125
- private setPalette;
126
- private setCanvas;
127
- private setLockFrame;
128
- private setTiles;
129
- private blendCanvases;
130
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
131
- private getDimensions;
98
+ declare class UrlCache {
99
+ static rendered: Record<string, string>;
100
+ static rendering: Record<string, Promise<string>>;
101
+ getUrl(hash: string): Promise<string | null>;
102
+ setUrl(hash: string, promise: Promise<string>): Promise<void>;
132
103
  }
133
104
 
134
105
  declare const decodeTile: (rawBytes?: string) => IndexedTilePixels;
135
106
 
136
- declare const getRGBValue: ({ pixels, index, tileIndex, imageStartLine, handleExportFrame, colorData, frameColorData, }: {
107
+ declare const getRGBValue: ({ pixels, index, tileIndex, imageContext: { imageStartLine, handleExportFrame, imagePalette, framePalette, }, }: {
137
108
  pixels: IndexedTilePixels;
138
109
  index: number;
139
110
  tileIndex: number;
140
- imageStartLine: number;
141
- handleExportFrame: ExportFrameMode;
142
- colorData: BWPalette;
143
- frameColorData: BWPalette;
111
+ imageContext: MonochromeImageContext;
144
112
  }) => RGBValue;
145
113
 
146
- declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame?: ExportFrameMode) => boolean;
114
+ declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame: ExportFrameMode) => boolean;
147
115
 
148
116
  declare const maxTiles: (rgbnTiles: RGBNTiles) => number;
149
117
 
118
+ declare const BLACK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
119
+ declare const WHITE = "00000000000000000000000000000000";
150
120
  declare const SKIP_LINE = "skip";
121
+ declare const TILE_PIXEL_WIDTH = 8;
122
+ declare const TILE_PIXEL_HEIGHT = 8;
123
+ declare const TILES_PER_LINE = 20;
124
+ declare const TILES_PER_COLUMN = 18;
125
+ declare const FRAME_WIDTH = 2;
151
126
  declare const BW_PALETTE: number[];
152
127
  declare const BW_PALETTE_HEX: string[];
128
+ declare const BLACK_LINE: string[];
129
+ declare const WHITE_LINE: string[];
130
+ declare const RGBN_SHADES: number[];
131
+ declare const defaultRGBNPalette: RGBNPalette;
153
132
 
154
- export { type BWPalette, BW_PALETTE, BW_PALETTE_HEX, BlendMode, type CanvasCreator, type ChangedTile, type Channel, ChannelKey, type Channels, Decoder, type DecoderOptions, type DecoderUpdateParams, ExportFrameMode, type ImageDataCreator, type IndexedTilePixels, RGBNDecoder, type RGBNDecoderUpdateParams, type RGBNPalette, type RGBNTiles, type RGBValue, SKIP_LINE, type ScaledCanvasSize, type SourceCanvases, blendModeNewName, decodeTile, getRGBValue, maxTiles, tileIndexIsPartOfFrame };
133
+ export { BLACK, BLACK_LINE, type BWPalette, BW_PALETTE, BW_PALETTE_HEX, type BaseImageContext, type BaseImageCreationParams, BlendMode, type CanvasCreator, ChannelKey, type CropResult, ExportFrameMode, FRAME_WIDTH, type FullMonochromeImageCreationParams, type FullRGBNImageCreationParams, type IndexedTilePixels, type MonochromeImageContext, type MonochromeImageCreationParams, type PixelDimensions, type RGBNImageCreationParams, type RGBNPalette, type RGBNTiles, RGBN_SHADES, type RGBValue, type RawOutput, SKIP_LINE, type SourceCanvases, TILES_PER_COLUMN, TILES_PER_LINE, TILE_PIXEL_HEIGHT, TILE_PIXEL_WIDTH, UrlCache, WHITE, WHITE_LINE, blendModeNewName, channels, decodeTile, defaultRGBNPalette, getDimensions, getMonochromeImageUrl, getRGBNImageUrl, getRGBValue, getRawMonochromeImageData, getRawRGBNImageData, maxTiles, scaleRawImageData, tileIndexIsPartOfFrame };
package/dist/index.d.mts CHANGED
@@ -28,27 +28,11 @@ declare enum ExportFrameMode {
28
28
  FRAMEMODE_SQUARE_BLACK = "square_black",
29
29
  FRAMEMODE_SQUARE_WHITE = "square_white"
30
30
  }
31
+ declare const channels: ChannelKey[];
31
32
 
32
- interface Channel<DecoderType> {
33
- key: ChannelKey;
34
- tiles?: string[];
35
- decoder: DecoderType;
36
- canvas: HTMLCanvasElement;
37
- }
38
33
  type RGBNTiles = Partial<Record<ChannelKey, string[]>>;
39
- type Channels<DecoderType> = Record<ChannelKey, Channel<DecoderType>>;
40
34
  type SourceCanvases = Partial<Record<ChannelKey, HTMLCanvasElement>>;
41
35
  type CanvasCreator = () => HTMLCanvasElement;
42
- type ImageDataCreator = (rawImageData: Uint8ClampedArray, width: number, height: number) => ImageData;
43
- interface ChangedTile {
44
- index: number;
45
- newTile: string;
46
- }
47
- interface ScaledCanvasSize {
48
- initialHeight: number;
49
- initialWidth: number;
50
- tilesPerLine: number;
51
- }
52
36
  interface RGBValue {
53
37
  r: number;
54
38
  g: number;
@@ -63,92 +47,87 @@ interface RGBNPalette {
63
47
  n?: number[];
64
48
  blend?: BlendMode;
65
49
  }
66
- interface DecoderOptions {
50
+ interface BaseImageCreationParams<TilesType> {
51
+ tiles: TilesType;
52
+ imageStartLine?: number;
67
53
  tilesPerLine?: number;
68
- canvasCreator?: CanvasCreator;
69
- imageDataCreator?: ImageDataCreator;
54
+ scaleFactor?: number;
55
+ handleExportFrame?: ExportFrameMode;
70
56
  }
71
- interface DecoderUpdateParams {
72
- canvas: HTMLCanvasElement | null;
73
- tiles: string[];
74
- palette: string[];
75
- framePalette: string[];
76
- imageStartLine?: number;
57
+ interface MonochromeImageCreationParams extends BaseImageCreationParams<string[]> {
58
+ imagePalette: BWPalette;
59
+ framePalette?: BWPalette;
77
60
  }
78
- interface RGBNDecoderUpdateParams {
79
- canvas: HTMLCanvasElement | null;
80
- tiles: RGBNTiles;
61
+ type FullMonochromeImageCreationParams = Required<MonochromeImageCreationParams>;
62
+ interface RGBNImageCreationParams extends BaseImageCreationParams<RGBNTiles> {
81
63
  palette: RGBNPalette;
82
64
  lockFrame?: boolean;
83
65
  }
84
-
85
- declare class Decoder {
86
- private canvas;
87
- private tiles;
88
- private colors;
89
- private frameColors;
90
- private rawImageData;
91
- private lockFrame;
92
- private colorData;
93
- private frameColorData;
94
- private tilesPerLine;
95
- private imageStartLine;
96
- private canvasCreator;
97
- private imageDataCreator;
98
- constructor(options?: DecoderOptions);
99
- update({ canvas, tiles, palette, framePalette, imageStartLine, }: DecoderUpdateParams): void;
100
- private setImageStartLine;
101
- private updateCanvas;
102
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
103
- private getScaledCanvasSize;
104
- private getExportTiles;
105
- private setCanvas;
106
- private setPalettes;
107
- private setTiles;
108
- private renderTile;
109
- private paintTile;
110
- private paintTileScaled;
111
- private getHeight;
112
- private getWidth;
66
+ type FullRGBNImageCreationParams = Required<RGBNImageCreationParams>;
67
+ interface PixelDimensions {
68
+ width: number;
69
+ height: number;
113
70
  }
71
+ interface BaseImageContext {
72
+ tilesPerLine: number;
73
+ imageStartLine: number;
74
+ handleExportFrame: ExportFrameMode;
75
+ }
76
+ interface MonochromeImageContext extends BaseImageContext {
77
+ imagePalette: BWPalette;
78
+ framePalette: BWPalette;
79
+ }
80
+ interface CropResult<ContextType> {
81
+ tiles: string[];
82
+ dimensions: PixelDimensions;
83
+ contextUpdates: Partial<ContextType>;
84
+ }
85
+ interface RawOutput {
86
+ data: Uint8ClampedArray;
87
+ dimensions: PixelDimensions;
88
+ }
89
+
90
+ declare const getDimensions: (tilesLength: number, tilesPerLine: number) => PixelDimensions;
91
+ declare const scaleRawImageData: (data: Uint8ClampedArray, width: number, height: number, scale: number) => RawOutput;
92
+ declare const getRawMonochromeImageData: (params: FullMonochromeImageCreationParams) => RawOutput;
93
+ declare const getMonochromeImageUrl: (params: MonochromeImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
94
+
95
+ declare const getRawRGBNImageData: (params: FullRGBNImageCreationParams, canvasCreator: CanvasCreator) => RawOutput;
96
+ declare const getRGBNImageUrl: (params: RGBNImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
114
97
 
115
- declare class RGBNDecoder {
116
- private canvas;
117
- private palette;
118
- private lockFrame;
119
- private channels;
120
- private tilesPerLine;
121
- private canvasCreator;
122
- private imageDataCreator;
123
- constructor(options?: DecoderOptions);
124
- update({ canvas, tiles, palette, lockFrame, }: RGBNDecoderUpdateParams): void;
125
- private setPalette;
126
- private setCanvas;
127
- private setLockFrame;
128
- private setTiles;
129
- private blendCanvases;
130
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
131
- private getDimensions;
98
+ declare class UrlCache {
99
+ static rendered: Record<string, string>;
100
+ static rendering: Record<string, Promise<string>>;
101
+ getUrl(hash: string): Promise<string | null>;
102
+ setUrl(hash: string, promise: Promise<string>): Promise<void>;
132
103
  }
133
104
 
134
105
  declare const decodeTile: (rawBytes?: string) => IndexedTilePixels;
135
106
 
136
- declare const getRGBValue: ({ pixels, index, tileIndex, imageStartLine, handleExportFrame, colorData, frameColorData, }: {
107
+ declare const getRGBValue: ({ pixels, index, tileIndex, imageContext: { imageStartLine, handleExportFrame, imagePalette, framePalette, }, }: {
137
108
  pixels: IndexedTilePixels;
138
109
  index: number;
139
110
  tileIndex: number;
140
- imageStartLine: number;
141
- handleExportFrame: ExportFrameMode;
142
- colorData: BWPalette;
143
- frameColorData: BWPalette;
111
+ imageContext: MonochromeImageContext;
144
112
  }) => RGBValue;
145
113
 
146
- declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame?: ExportFrameMode) => boolean;
114
+ declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame: ExportFrameMode) => boolean;
147
115
 
148
116
  declare const maxTiles: (rgbnTiles: RGBNTiles) => number;
149
117
 
118
+ declare const BLACK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
119
+ declare const WHITE = "00000000000000000000000000000000";
150
120
  declare const SKIP_LINE = "skip";
121
+ declare const TILE_PIXEL_WIDTH = 8;
122
+ declare const TILE_PIXEL_HEIGHT = 8;
123
+ declare const TILES_PER_LINE = 20;
124
+ declare const TILES_PER_COLUMN = 18;
125
+ declare const FRAME_WIDTH = 2;
151
126
  declare const BW_PALETTE: number[];
152
127
  declare const BW_PALETTE_HEX: string[];
128
+ declare const BLACK_LINE: string[];
129
+ declare const WHITE_LINE: string[];
130
+ declare const RGBN_SHADES: number[];
131
+ declare const defaultRGBNPalette: RGBNPalette;
153
132
 
154
- export { type BWPalette, BW_PALETTE, BW_PALETTE_HEX, BlendMode, type CanvasCreator, type ChangedTile, type Channel, ChannelKey, type Channels, Decoder, type DecoderOptions, type DecoderUpdateParams, ExportFrameMode, type ImageDataCreator, type IndexedTilePixels, RGBNDecoder, type RGBNDecoderUpdateParams, type RGBNPalette, type RGBNTiles, type RGBValue, SKIP_LINE, type ScaledCanvasSize, type SourceCanvases, blendModeNewName, decodeTile, getRGBValue, maxTiles, tileIndexIsPartOfFrame };
133
+ export { BLACK, BLACK_LINE, type BWPalette, BW_PALETTE, BW_PALETTE_HEX, type BaseImageContext, type BaseImageCreationParams, BlendMode, type CanvasCreator, ChannelKey, type CropResult, ExportFrameMode, FRAME_WIDTH, type FullMonochromeImageCreationParams, type FullRGBNImageCreationParams, type IndexedTilePixels, type MonochromeImageContext, type MonochromeImageCreationParams, type PixelDimensions, type RGBNImageCreationParams, type RGBNPalette, type RGBNTiles, RGBN_SHADES, type RGBValue, type RawOutput, SKIP_LINE, type SourceCanvases, TILES_PER_COLUMN, TILES_PER_LINE, TILE_PIXEL_HEIGHT, TILE_PIXEL_WIDTH, UrlCache, WHITE, WHITE_LINE, blendModeNewName, channels, decodeTile, defaultRGBNPalette, getDimensions, getMonochromeImageUrl, getRGBNImageUrl, getRGBValue, getRawMonochromeImageData, getRawRGBNImageData, maxTiles, scaleRawImageData, tileIndexIsPartOfFrame };
package/dist/index.d.ts CHANGED
@@ -28,27 +28,11 @@ declare enum ExportFrameMode {
28
28
  FRAMEMODE_SQUARE_BLACK = "square_black",
29
29
  FRAMEMODE_SQUARE_WHITE = "square_white"
30
30
  }
31
+ declare const channels: ChannelKey[];
31
32
 
32
- interface Channel<DecoderType> {
33
- key: ChannelKey;
34
- tiles?: string[];
35
- decoder: DecoderType;
36
- canvas: HTMLCanvasElement;
37
- }
38
33
  type RGBNTiles = Partial<Record<ChannelKey, string[]>>;
39
- type Channels<DecoderType> = Record<ChannelKey, Channel<DecoderType>>;
40
34
  type SourceCanvases = Partial<Record<ChannelKey, HTMLCanvasElement>>;
41
35
  type CanvasCreator = () => HTMLCanvasElement;
42
- type ImageDataCreator = (rawImageData: Uint8ClampedArray, width: number, height: number) => ImageData;
43
- interface ChangedTile {
44
- index: number;
45
- newTile: string;
46
- }
47
- interface ScaledCanvasSize {
48
- initialHeight: number;
49
- initialWidth: number;
50
- tilesPerLine: number;
51
- }
52
36
  interface RGBValue {
53
37
  r: number;
54
38
  g: number;
@@ -63,92 +47,87 @@ interface RGBNPalette {
63
47
  n?: number[];
64
48
  blend?: BlendMode;
65
49
  }
66
- interface DecoderOptions {
50
+ interface BaseImageCreationParams<TilesType> {
51
+ tiles: TilesType;
52
+ imageStartLine?: number;
67
53
  tilesPerLine?: number;
68
- canvasCreator?: CanvasCreator;
69
- imageDataCreator?: ImageDataCreator;
54
+ scaleFactor?: number;
55
+ handleExportFrame?: ExportFrameMode;
70
56
  }
71
- interface DecoderUpdateParams {
72
- canvas: HTMLCanvasElement | null;
73
- tiles: string[];
74
- palette: string[];
75
- framePalette: string[];
76
- imageStartLine?: number;
57
+ interface MonochromeImageCreationParams extends BaseImageCreationParams<string[]> {
58
+ imagePalette: BWPalette;
59
+ framePalette?: BWPalette;
77
60
  }
78
- interface RGBNDecoderUpdateParams {
79
- canvas: HTMLCanvasElement | null;
80
- tiles: RGBNTiles;
61
+ type FullMonochromeImageCreationParams = Required<MonochromeImageCreationParams>;
62
+ interface RGBNImageCreationParams extends BaseImageCreationParams<RGBNTiles> {
81
63
  palette: RGBNPalette;
82
64
  lockFrame?: boolean;
83
65
  }
84
-
85
- declare class Decoder {
86
- private canvas;
87
- private tiles;
88
- private colors;
89
- private frameColors;
90
- private rawImageData;
91
- private lockFrame;
92
- private colorData;
93
- private frameColorData;
94
- private tilesPerLine;
95
- private imageStartLine;
96
- private canvasCreator;
97
- private imageDataCreator;
98
- constructor(options?: DecoderOptions);
99
- update({ canvas, tiles, palette, framePalette, imageStartLine, }: DecoderUpdateParams): void;
100
- private setImageStartLine;
101
- private updateCanvas;
102
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
103
- private getScaledCanvasSize;
104
- private getExportTiles;
105
- private setCanvas;
106
- private setPalettes;
107
- private setTiles;
108
- private renderTile;
109
- private paintTile;
110
- private paintTileScaled;
111
- private getHeight;
112
- private getWidth;
66
+ type FullRGBNImageCreationParams = Required<RGBNImageCreationParams>;
67
+ interface PixelDimensions {
68
+ width: number;
69
+ height: number;
113
70
  }
71
+ interface BaseImageContext {
72
+ tilesPerLine: number;
73
+ imageStartLine: number;
74
+ handleExportFrame: ExportFrameMode;
75
+ }
76
+ interface MonochromeImageContext extends BaseImageContext {
77
+ imagePalette: BWPalette;
78
+ framePalette: BWPalette;
79
+ }
80
+ interface CropResult<ContextType> {
81
+ tiles: string[];
82
+ dimensions: PixelDimensions;
83
+ contextUpdates: Partial<ContextType>;
84
+ }
85
+ interface RawOutput {
86
+ data: Uint8ClampedArray;
87
+ dimensions: PixelDimensions;
88
+ }
89
+
90
+ declare const getDimensions: (tilesLength: number, tilesPerLine: number) => PixelDimensions;
91
+ declare const scaleRawImageData: (data: Uint8ClampedArray, width: number, height: number, scale: number) => RawOutput;
92
+ declare const getRawMonochromeImageData: (params: FullMonochromeImageCreationParams) => RawOutput;
93
+ declare const getMonochromeImageUrl: (params: MonochromeImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
94
+
95
+ declare const getRawRGBNImageData: (params: FullRGBNImageCreationParams, canvasCreator: CanvasCreator) => RawOutput;
96
+ declare const getRGBNImageUrl: (params: RGBNImageCreationParams, canvasCreator?: CanvasCreator) => Promise<string>;
114
97
 
115
- declare class RGBNDecoder {
116
- private canvas;
117
- private palette;
118
- private lockFrame;
119
- private channels;
120
- private tilesPerLine;
121
- private canvasCreator;
122
- private imageDataCreator;
123
- constructor(options?: DecoderOptions);
124
- update({ canvas, tiles, palette, lockFrame, }: RGBNDecoderUpdateParams): void;
125
- private setPalette;
126
- private setCanvas;
127
- private setLockFrame;
128
- private setTiles;
129
- private blendCanvases;
130
- getScaledCanvas(scaleFactor: number, handleExportFrame?: ExportFrameMode): HTMLCanvasElement;
131
- private getDimensions;
98
+ declare class UrlCache {
99
+ static rendered: Record<string, string>;
100
+ static rendering: Record<string, Promise<string>>;
101
+ getUrl(hash: string): Promise<string | null>;
102
+ setUrl(hash: string, promise: Promise<string>): Promise<void>;
132
103
  }
133
104
 
134
105
  declare const decodeTile: (rawBytes?: string) => IndexedTilePixels;
135
106
 
136
- declare const getRGBValue: ({ pixels, index, tileIndex, imageStartLine, handleExportFrame, colorData, frameColorData, }: {
107
+ declare const getRGBValue: ({ pixels, index, tileIndex, imageContext: { imageStartLine, handleExportFrame, imagePalette, framePalette, }, }: {
137
108
  pixels: IndexedTilePixels;
138
109
  index: number;
139
110
  tileIndex: number;
140
- imageStartLine: number;
141
- handleExportFrame: ExportFrameMode;
142
- colorData: BWPalette;
143
- frameColorData: BWPalette;
111
+ imageContext: MonochromeImageContext;
144
112
  }) => RGBValue;
145
113
 
146
- declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame?: ExportFrameMode) => boolean;
114
+ declare const tileIndexIsPartOfFrame: (tileIndex: number, imageStartLine: number, handleExportFrame: ExportFrameMode) => boolean;
147
115
 
148
116
  declare const maxTiles: (rgbnTiles: RGBNTiles) => number;
149
117
 
118
+ declare const BLACK = "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF";
119
+ declare const WHITE = "00000000000000000000000000000000";
150
120
  declare const SKIP_LINE = "skip";
121
+ declare const TILE_PIXEL_WIDTH = 8;
122
+ declare const TILE_PIXEL_HEIGHT = 8;
123
+ declare const TILES_PER_LINE = 20;
124
+ declare const TILES_PER_COLUMN = 18;
125
+ declare const FRAME_WIDTH = 2;
151
126
  declare const BW_PALETTE: number[];
152
127
  declare const BW_PALETTE_HEX: string[];
128
+ declare const BLACK_LINE: string[];
129
+ declare const WHITE_LINE: string[];
130
+ declare const RGBN_SHADES: number[];
131
+ declare const defaultRGBNPalette: RGBNPalette;
153
132
 
154
- export { type BWPalette, BW_PALETTE, BW_PALETTE_HEX, BlendMode, type CanvasCreator, type ChangedTile, type Channel, ChannelKey, type Channels, Decoder, type DecoderOptions, type DecoderUpdateParams, ExportFrameMode, type ImageDataCreator, type IndexedTilePixels, RGBNDecoder, type RGBNDecoderUpdateParams, type RGBNPalette, type RGBNTiles, type RGBValue, SKIP_LINE, type ScaledCanvasSize, type SourceCanvases, blendModeNewName, decodeTile, getRGBValue, maxTiles, tileIndexIsPartOfFrame };
133
+ export { BLACK, BLACK_LINE, type BWPalette, BW_PALETTE, BW_PALETTE_HEX, type BaseImageContext, type BaseImageCreationParams, BlendMode, type CanvasCreator, ChannelKey, type CropResult, ExportFrameMode, FRAME_WIDTH, type FullMonochromeImageCreationParams, type FullRGBNImageCreationParams, type IndexedTilePixels, type MonochromeImageContext, type MonochromeImageCreationParams, type PixelDimensions, type RGBNImageCreationParams, type RGBNPalette, type RGBNTiles, RGBN_SHADES, type RGBValue, type RawOutput, SKIP_LINE, type SourceCanvases, TILES_PER_COLUMN, TILES_PER_LINE, TILE_PIXEL_HEIGHT, TILE_PIXEL_WIDTH, UrlCache, WHITE, WHITE_LINE, blendModeNewName, channels, decodeTile, defaultRGBNPalette, getDimensions, getMonochromeImageUrl, getRGBNImageUrl, getRGBValue, getRawMonochromeImageData, getRawRGBNImageData, maxTiles, scaleRawImageData, tileIndexIsPartOfFrame };