fix: add bypass for gif image if nothing to do

Author: wchaws

source/new-image-handler/src/processor/image/_base.ts

@@ -1,11 +1,72 @@
-import { IAction, IActionOpts, IProcessContext, ReadOnly } from '..';
+import { IImageContext } from '.';
+import { IAction, IActionOpts, IProcessContext, ReadOnly, IActionMask } from '..';
 
 
 export abstract class BaseImageAction implements IAction {
   public name: string = 'unknown';
   abstract validate(params: string[]): ReadOnly<IActionOpts>;
   abstract process(ctx: IProcessContext, params: string[]): Promise<void>;
-  public beforeNewContext(_: IProcessContext, params: string[]): void {
+  public beforeNewContext(_1: IProcessContext, params: string[], _3: number): void {
     this.validate(params);
   }
+  public beforeProcess(_1: IImageContext, _2: string[], _3: number): void { }
 }
+
+export class ActionMask implements IActionMask {
+  private readonly _masks: boolean[];
+
+  public constructor(private readonly _actions: string[]) {
+    this._masks = _actions.map(() => true);
+  }
+
+  public get length(): number {
+    return this._actions.length;
+  }
+
+  private _check(index: number): void {
+    if (!(0 <= index && index < this.length)) {
+      throw new Error('Index out of range');
+    }
+  }
+
+  public getAction(index: number): string {
+    this._check(index);
+    return this._actions[index];
+  }
+
+  public isEnabled(index: number): boolean {
+    this._check(index);
+    return this._masks[index];
+  }
+
+  public isDisabled(index: number): boolean {
+    this._check(index);
+    return !this._masks[index];
+  }
+
+  public enable(index: number) {
+    this._check(index);
+    this._masks[index] = true;
+  }
+
+  public disable(index: number) {
+    this._check(index);
+    this._masks[index] = false;
+  }
+
+  public disableAll() {
+    for (let i = 0; i < this._masks.length; i++) {
+      this._masks[i] = false;
+    }
+  }
+
+  public filterEnabledActions(): string[] {
+    return this._actions.filter((_, index) => this._masks[index]);
+  }
+
+  public forEachAction(cb: (action: string, enabled: boolean, index: number) => void): void {
+    this._actions.forEach((action, index) => {
+      cb(action, this.isEnabled(index), index);
+    });
+  }
+}

source/new-image-handler/src/processor/image/format.ts

@@ -18,6 +18,13 @@ export class FormatAction extends BaseImageAction {
     }
   }
 
+  public beforeProcess(ctx: IImageContext, params: string[], index: number): void {
+    const opts = this.validate(params);
+    if (('gif' === ctx.metadata.format) && ('gif' === opts.format)) {
+      ctx.mask.disable(index);
+    }
+  }
+
   public validate(params: string[]): ReadOnly<FormatOpts> {
     let opt: FormatOpts = { format: '' };
 

source/new-image-handler/src/processor/image/index.ts

@@ -1,6 +1,7 @@
 import * as sharp from 'sharp';
 import { Features, IAction, InvalidArgument, IProcessContext, IProcessor, IProcessResponse } from '../../processor';
 import { IBufferStore } from '../../store';
+import { ActionMask } from './_base';
 import { AutoOrientAction } from './auto-orient';
 import { BlurAction } from './blur';
 import { BrightAction } from './bright';
@@ -46,14 +47,16 @@ export class ImageProcessor implements IProcessor {
     const ctx: IProcessContext = {
       uri,
       actions,
+      mask: new ActionMask(actions),
       bufferStore,
       features: {
         [Features.AutoOrient]: true,
         [Features.ReadAllAnimatedFrames]: true,
       },
       headers: {},
     };
-    for (const action of actions) {
+    for (let i = 0; i < actions.length; i++) {
+      const action = actions[i];
       if ((this.name === action) || (!action)) {
         continue;
       }
@@ -64,7 +67,7 @@ export class ImageProcessor implements IProcessor {
       if (!act) {
         throw new InvalidArgument(`Unkown action: "${name}"`);
       }
-      act.beforeNewContext.bind(act)(ctx, params);
+      act.beforeNewContext.bind(act)(ctx, params, i);
     }
     const { buffer, headers } = await bufferStore.get(uri);
     const image = sharp(buffer, { failOnError: false, animated: ctx.features[Features.ReadAllAnimatedFrames] });
@@ -77,7 +80,7 @@ export class ImageProcessor implements IProcessor {
     return {
       uri: ctx.uri,
       actions: ctx.actions,
-      effectiveActions: ctx.effectiveActions,
+      mask: ctx.mask,
       bufferStore: ctx.bufferStore,
       features: ctx.features,
       headers: Object.assign(ctx.headers, headers),
@@ -96,8 +99,28 @@ export class ImageProcessor implements IProcessor {
 
     if (ctx.features[Features.AutoOrient]) { ctx.image.rotate(); }
 
-    const actions = (ctx.effectiveActions && ctx.effectiveActions.length) ? ctx.effectiveActions : ctx.actions;
-    for (const action of actions) {
+    ctx.mask.forEachAction((action, _, index) => {
+      if ((this.name === action) || (!action)) {
+        return;
+      }
+      // "<action-name>,<param-1>,<param-2>,..."
+      const params = action.split(',');
+      const name = params[0];
+      const act = this.action(name);
+      if (!act) {
+        throw new InvalidArgument(`Unkown action: "${name}"`);
+      }
+      act.beforeProcess.bind(act)(ctx, params, index);
+    });
+    const enabledActions = ctx.mask.filterEnabledActions();
+    const nothing2do = (enabledActions.length === 1) && (this.name === enabledActions[0]);
+
+    if (nothing2do && (!ctx.features[Features.AutoWebp])) {
+      const { buffer } = await ctx.bufferStore.get(ctx.uri);
+      return { data: buffer, type: ctx.metadata.format! };
+    }
+
+    for (const action of enabledActions) {
       if ((this.name === action) || (!action)) {
         continue;
       }

source/new-image-handler/src/processor/image/info.ts

@@ -1,20 +1,14 @@
 import { IImageContext } from '.';
-import { IActionOpts, ReadOnly, InvalidArgument, Features, IProcessContext } from '..';
+import { IActionOpts, ReadOnly, InvalidArgument, Features } from '..';
 import { BaseImageAction } from './_base';
 
 
 export class InfoAction extends BaseImageAction {
   public readonly name: string = 'info';
 
-  public beforeNewContext(ctx: IProcessContext, params: string[]): void {
-    this.validate(params);
-
-    const action = params.join(',');
-    if (ctx.effectiveActions) {
-      ctx.effectiveActions.push(action);
-    } else {
-      ctx.effectiveActions = [action];
-    }
+  public beforeProcess(ctx: IImageContext, _2: string[], index: number): void {
+    ctx.mask.disableAll();
+    ctx.mask.enable(index);
   }
 
   public validate(params: string[]): ReadOnly<IActionOpts> {

source/new-image-handler/src/processor/image/quality.ts

@@ -18,6 +18,12 @@ export interface QualityOpts extends IActionOpts {
 export class QualityAction extends BaseImageAction {
   public readonly name: string = 'quality';
 
+  public beforeProcess(ctx: IImageContext, _2: string[], index: number): void {
+    if ('gif' === ctx.metadata.format) {
+      ctx.mask.disable(index);
+    }
+  }
+
   public validate(params: string[]): ReadOnly<QualityOpts> {
     const opt: QualityOpts = {};
     for (const param of params) {

source/new-image-handler/src/processor/index.ts

@@ -8,6 +8,18 @@ export type ReadOnly<T> = {
   readonly [K in keyof T]: ReadOnly<T[K]>;
 }
 
+export interface IActionMask {
+  readonly length: number;
+  getAction(index: number): string;
+  isEnabled(index: number): boolean;
+  isDisabled(index: number): boolean;
+  enable(index: number): void;
+  disable(index: number): void;
+  disableAll(): void;
+  filterEnabledActions(): string[];
+  forEachAction(cb: (action: string, enabled: boolean, index: number) => void): void;
+}
+
 /**
  * Context object for processor.
  */
@@ -22,12 +34,7 @@ export interface IProcessContext {
    */
   readonly actions: string[];
 
-  /**
-   * The effective actions.
-   * If this value is undefined or empty list. All actions will be effective.
-   * Otherwise, only the action in this list will be effective.
-   */
-  effectiveActions?: string[];
+  readonly mask: IActionMask;
 
   /**
    * A abstract store to get file data.
@@ -149,7 +156,9 @@ export interface IAction {
    * @param ctx the context
    * @param params the parameters
    */
-  beforeNewContext(ctx: IProcessContext, params: string[]): void;
+  beforeNewContext(ctx: IProcessContext, params: string[], index: number): void;
+
+  beforeProcess(ctx: IProcessContext, params: string[], index: number): void;
 }
 
 /**

source/new-image-handler/src/processor/style.ts

@@ -1,6 +1,7 @@
 import { IAction, InvalidArgument, IProcessContext, IProcessor, IProcessResponse } from '.';
 import * as is from '../is';
 import { IBufferStore, IKVStore, MemKVStore } from '../store';
+import { ActionMask } from './image/_base';
 import { ImageProcessor } from './image/index';
 import { VideoProcessor } from './video';
 
@@ -32,6 +33,7 @@ export class StyleProcessor implements IProcessor {
     return Promise.resolve({
       uri,
       actions,
+      mask: new ActionMask(actions),
       bufferStore,
       headers: {},
       features: {},

source/new-image-handler/src/processor/video.ts

@@ -2,6 +2,7 @@ import * as child_process from 'child_process';
 import { IAction, InvalidArgument, IProcessContext, IProcessor, IProcessResponse, IActionOpts, ReadOnly } from '.';
 import * as is from '../is';
 import { IBufferStore } from '../store';
+import { ActionMask } from './image/_base';
 
 export interface VideoOpts extends IActionOpts {
   t: number; // 指定截图时间, 单位：s
@@ -27,6 +28,7 @@ export class VideoProcessor implements IProcessor {
     return Promise.resolve({
       uri,
       actions,
+      mask: new ActionMask(actions),
       bufferStore,
       features: {},
       headers: {},

source/new-image-handler/test/processor/image/_base.test.ts

@@ -0,0 +1,61 @@
+import { ActionMask } from '../../../src/processor/image/_base';
+
+test(`${ActionMask.name} all enabled by default`, () => {
+  const actions = '1 1 1 1 1 1'.split(' ');
+  const s = new ActionMask(actions);
+
+  expect(s.length).toBe(actions.length);
+  expect(s.filterEnabledActions()).toEqual(actions);
+});
+
+test(`${ActionMask.name} getAction`, () => {
+  const actions = '1 2 3 4 5 6'.split(' ');
+  const s = new ActionMask(actions);
+
+  expect(s.length).toBe(actions.length);
+
+  s.disable(0);
+  s.enable(0);
+  expect(s.isDisabled(0)).toBeFalsy();
+
+  s.forEachAction((action, enable, index) => {
+    expect(s.getAction(index)).toEqual(action);
+    expect(s.isEnabled(index)).toBe(enable);
+    expect(action).toBe(`${1 + index}`);
+  });
+});
+
+test(`${ActionMask.name} enable/disable`, () => {
+  const actions = '1 2 3 4 5 6'.split(' ');
+  const s = new ActionMask(actions);
+
+  expect(s.length).toBe(actions.length);
+  s.disable(0);
+  s.disable(1);
+  s.disable(2);
+  expect(s.filterEnabledActions().length).toBe(3);
+  expect(s.filterEnabledActions()).toEqual('4 5 6'.split(' '));
+});
+
+test(`${ActionMask.name} forEach enable/disable`, () => {
+  const actions = '1 2 3 4 5 6'.split(' ');
+  const s = new ActionMask(actions);
+
+  expect(s.length).toBe(actions.length);
+  s.forEachAction((_, enabled, index) => {
+    expect(enabled).toBeTruthy();
+    s.disable(index);
+  });
+  expect(s.filterEnabledActions()).toEqual([]);
+});
+
+test(`${ActionMask.name} index out of range`, () => {
+  const actions = '1 2 3 4 5 6'.split(' ');
+  const s = new ActionMask(actions);
+
+  expect(() => {
+    s.enable(-1);
+  }).toThrowError(/Index out of range/);
+});
+
+

source/new-image-handler/test/processor/image/utils.ts

@@ -1,6 +1,7 @@
 import * as path from 'path';
 import * as sharp from 'sharp';
 import { IImageContext } from '../../../src/processor/image';
+import { ActionMask } from '../../../src/processor/image/_base';
 import { IBufferStore, LocalStore } from '../../../src/store';
 
 export const fixtureStore = new LocalStore(path.join(__dirname, '../../fixtures'));
@@ -12,5 +13,8 @@ export async function mkctx(name: string, actions?: string[], bufferStore?: IBuf
   const image = sharp((await bufferStore.get(name)).buffer, {
     animated: (name.endsWith('.gif') || name.endsWith('.webp')),
   });
-  return { uri: name, actions: actions ?? [], image, bufferStore, features: {}, headers: {}, metadata: await image.metadata() };
+
+  const actions2 = actions ?? [];
+  const mask = new ActionMask(actions2);
+  return { uri: name, actions: actions2, mask, image, bufferStore, features: {}, headers: {}, metadata: await image.metadata() };
 }