styles: singleQuote

bilibili · Feb 5, 2024 · e65bef4 · e65bef4
1 parent cf8ec13
commit e65bef4
Show file tree

Hide file tree

Showing 68 changed files with 864 additions and 861 deletions.
diff --git a/.prettierrc b/.prettierrc
@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}
diff --git a/packages/av-canvas/demo/record-avcanvas.ts b/packages/av-canvas/demo/record-avcanvas.ts
@@ -1,20 +1,20 @@
-import { Combinator } from "@webav/av-cliper";
+import { Combinator } from '@webav/av-cliper';
 import {
   AVCanvas,
   AudioSprite,
   TextSprite,
   ImgSprite,
   VideoSprite,
-} from "../src/index";
-import { AVRecorder } from "@webav/av-recorder";
+} from '../src/index';
+import { AVRecorder } from '@webav/av-recorder';
 (async () => {
   if (!(await Combinator.isSupported())) {
-    alert("Your browser does not support WebCodecs");
+    alert('Your browser does not support WebCodecs');
   }
 })();
 
-const avCvs = new AVCanvas(document.querySelector("#app") as HTMLElement, {
-  bgColor: "#333",
+const avCvs = new AVCanvas(document.querySelector('#app') as HTMLElement, {
+  bgColor: '#333',
   resolution: {
     width: 1920,
     height: 1080,
@@ -26,112 +26,112 @@ console.log({ avCvs });
   // const is = new ImgSprite('img', 'https://neo-pages.bilibili.com/bbfe/neo/assets/img/neo-pages-overview.48f7bb81.png')
   // await avCvs.spriteManager.addSprite(is)
 })().catch(console.error);
-document.querySelector("#userMedia")?.addEventListener("click", () => {
+document.querySelector('#userMedia')?.addEventListener('click', () => {
   (async () => {
     const mediaStream = await navigator.mediaDevices.getUserMedia({
       video: true,
       audio: true,
     });
-    const vs = new VideoSprite("userMedia", mediaStream, {
+    const vs = new VideoSprite('userMedia', mediaStream, {
       audioCtx: avCvs.spriteManager.audioCtx,
     });
     await avCvs.spriteManager.addSprite(vs);
   })().catch(console.error);
 });
 
-document.querySelector("#display")?.addEventListener("click", () => {
+document.querySelector('#display')?.addEventListener('click', () => {
   (async () => {
     const mediaStream = await navigator.mediaDevices.getDisplayMedia({
       video: true,
       audio: true,
     });
-    const vs = new VideoSprite("display", mediaStream, {
+    const vs = new VideoSprite('display', mediaStream, {
       audioCtx: avCvs.spriteManager.audioCtx,
     });
     await avCvs.spriteManager.addSprite(vs);
   })().catch(console.error);
 });
 
-document.querySelector("#localImg")?.addEventListener("click", () => {
+document.querySelector('#localImg')?.addEventListener('click', () => {
   (async () => {
     const [imgFH] = await (window as any).showOpenFilePicker({
       types: [
         {
-          description: "Images",
+          description: 'Images',
           accept: {
-            "image/*": [".png", ".gif", ".jpeg", ".jpg"],
+            'image/*': ['.png', '.gif', '.jpeg', '.jpg'],
           },
         },
       ],
     });
-    const is = new ImgSprite("img", await imgFH.getFile());
+    const is = new ImgSprite('img', await imgFH.getFile());
     await avCvs.spriteManager.addSprite(is);
   })().catch(console.error);
 });
 
-document.querySelector("#localVideo")?.addEventListener("click", () => {
+document.querySelector('#localVideo')?.addEventListener('click', () => {
   (async () => {
     const [imgFH] = await (window as any).showOpenFilePicker({
       types: [
         {
-          description: "Video",
+          description: 'Video',
           accept: {
-            "video/*": [".webm", ".mp4"],
+            'video/*': ['.webm', '.mp4'],
           },
         },
       ],
     });
-    const vs = new VideoSprite("vs", await imgFH.getFile(), {
+    const vs = new VideoSprite('vs', await imgFH.getFile(), {
       audioCtx: avCvs.spriteManager.audioCtx,
     });
     await avCvs.spriteManager.addSprite(vs);
   })().catch(console.error);
 });
 
-document.querySelector("#localAudio")?.addEventListener("click", () => {
+document.querySelector('#localAudio')?.addEventListener('click', () => {
   (async () => {
     const [imgFH] = await (window as any).showOpenFilePicker({
       types: [
         {
-          description: "Audio",
+          description: 'Audio',
           accept: {
-            "audio/*": [".mp3", ".wav", ".ogg"],
+            'audio/*': ['.mp3', '.wav', '.ogg'],
           },
         },
       ],
     });
-    const as = new AudioSprite("vs", await imgFH.getFile(), {
+    const as = new AudioSprite('vs', await imgFH.getFile(), {
       audioCtx: avCvs.spriteManager.audioCtx,
     });
     await avCvs.spriteManager.addSprite(as);
   })().catch(console.error);
 });
 
-document.querySelector("#fontExamp")?.addEventListener("click", () => {
+document.querySelector('#fontExamp')?.addEventListener('click', () => {
   (async () => {
-    const textSpr = new TextSprite("text", "示例文字");
+    const textSpr = new TextSprite('text', '示例文字');
     await avCvs.spriteManager.addSprite(textSpr);
   })().catch(console.error);
 });
 
 let recorder: AVRecorder | null = null;
-document.querySelector("#startRecod")?.addEventListener("click", () => {
+document.querySelector('#startRecod')?.addEventListener('click', () => {
   (async () => {
-    const writer = await createFileWriter("mp4");
+    const writer = await createFileWriter('mp4');
     recorder = new AVRecorder(avCvs.captureStream(), {
       width: 1920,
       height: 1080,
       bitrate: 5e6,
-      audioCodec: "aac",
+      audioCodec: 'aac',
     });
     await recorder.start();
     recorder.outputStream?.pipeTo(writer).catch(console.error);
   })().catch(console.error);
 });
-document.querySelector("#stopRecod")?.addEventListener("click", () => {
+document.querySelector('#stopRecod')?.addEventListener('click', () => {
   (async () => {
     await recorder?.stop();
-    alert("save done");
+    alert('save done');
   })().catch(console.error);
 });
 

diff --git a/packages/av-canvas/src/__tests__/av-canvas.test.ts b/packages/av-canvas/src/__tests__/av-canvas.test.ts
@@ -1,19 +1,19 @@
-import "./mock";
-import { beforeEach, expect, test, vi } from "vitest";
-import { AVCanvas } from "../av-canvas";
-import { createEl } from "../utils";
-import { VideoSprite } from "../sprites/video-sprite";
-import { crtMSEvt4Offset, cvsCaptureStreamMock, CvsElementMock } from "./mock";
+import './mock';
+import { beforeEach, expect, test, vi } from 'vitest';
+import { AVCanvas } from '../av-canvas';
+import { createEl } from '../utils';
+import { VideoSprite } from '../sprites/video-sprite';
+import { crtMSEvt4Offset, cvsCaptureStreamMock, CvsElementMock } from './mock';
 
 function createAVCanvas(): {
   avCvs: AVCanvas;
   container: HTMLElement;
 } {
-  const container = createEl("div");
+  const container = createEl('div');
   return {
     avCvs: new AVCanvas(container, {
       resolution: { width: 100, height: 100 },
-      bgColor: "#333",
+      bgColor: '#333',
     }),
     container,
   };
@@ -33,14 +33,14 @@ beforeEach(() => {
   container = d.container;
 });
 
-test("av-canvas create & destroy", () => {
-  const spyMngDestroy = vi.spyOn(avCvs.spriteManager, "destroy");
+test('av-canvas create & destroy', () => {
+  const spyMngDestroy = vi.spyOn(avCvs.spriteManager, 'destroy');
   avCvs.destroy();
   expect(spyMngDestroy).toBeCalled();
 });
 
-test("init center the Sprite", async () => {
-  const vs = new VideoSprite("vs", new MediaStream());
+test('init center the Sprite', async () => {
+  const vs = new VideoSprite('vs', new MediaStream());
   await vs.initReady;
   vs.rect.w = 80;
   vs.rect.h = 80;
@@ -49,65 +49,65 @@ test("init center the Sprite", async () => {
   expect(vs.rect.y).toBe((100 - 80) / 2);
 });
 
-test("captureStream", () => {
+test('captureStream', () => {
   const mockMS = new MediaStream();
   cvsCaptureStreamMock.mockReturnValueOnce(mockMS);
-  vi.spyOn(mockMS, "getTracks").mockReturnValue(["mock-track"] as any);
+  vi.spyOn(mockMS, 'getTracks').mockReturnValue(['mock-track'] as any);
 
   const ms = avCvs.captureStream();
   expect(ms).toBeInstanceOf(MediaStream);
-  expect(ms.addTrack).toBeCalledWith("mock-track");
+  expect(ms.addTrack).toBeCalledWith('mock-track');
 });
 
-test("activeSprite", async () => {
-  const vs = new VideoSprite("vs", new MediaStream());
+test('activeSprite', async () => {
+  const vs = new VideoSprite('vs', new MediaStream());
   await vs.initReady;
   vs.rect.w = 80;
   vs.rect.h = 80;
   await avCvs.spriteManager.addSprite(vs);
 
-  const cvsEl = container.querySelector("canvas") as HTMLCanvasElement;
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousedown", 20, 20));
+  const cvsEl = container.querySelector('canvas') as HTMLCanvasElement;
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousedown', 20, 20));
   expect(avCvs.spriteManager.activeSprite).toBe(vs);
 
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousedown", 10, 10));
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousedown', 10, 10));
   // 命中 ctrls.lt
   expect(avCvs.spriteManager.activeSprite).toBe(vs);
 
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousedown", 0, 0));
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousedown', 0, 0));
   expect(avCvs.spriteManager.activeSprite).toBeNull();
 });
 
-test("dynamicCusor", async () => {
-  const vs = new VideoSprite("vs", new MediaStream());
+test('dynamicCusor', async () => {
+  const vs = new VideoSprite('vs', new MediaStream());
   await vs.initReady;
   vs.rect.w = 80;
   vs.rect.h = 80;
   await avCvs.spriteManager.addSprite(vs);
-  const cvsEl = container.querySelector("canvas") as HTMLCanvasElement;
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousedown", 20, 20));
-  window.dispatchEvent(crtMSEvt4Offset("mouseup", 20, 20));
+  const cvsEl = container.querySelector('canvas') as HTMLCanvasElement;
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousedown', 20, 20));
+  window.dispatchEvent(crtMSEvt4Offset('mouseup', 20, 20));
 
   expect(avCvs.spriteManager.activeSprite).toBe(vs);
-  expect(cvsEl.style.cursor).toBe("move");
+  expect(cvsEl.style.cursor).toBe('move');
 
   const {
     center,
     ctrls: { lt, rotate },
   } = vs.rect;
   cvsEl.dispatchEvent(
-    crtMSEvt4Offset("mousemove", lt.x + center.x, lt.y + center.y),
+    crtMSEvt4Offset('mousemove', lt.x + center.x, lt.y + center.y),
   );
-  expect(cvsEl.style.cursor).toBe("nwse-resize");
+  expect(cvsEl.style.cursor).toBe('nwse-resize');
 
   cvsEl.dispatchEvent(
-    crtMSEvt4Offset("mousemove", rotate.x + center.x, rotate.y + center.y),
+    crtMSEvt4Offset('mousemove', rotate.x + center.x, rotate.y + center.y),
   );
-  expect(cvsEl.style.cursor).toBe("crosshair");
+  expect(cvsEl.style.cursor).toBe('crosshair');
 
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousemove", 0, 0));
-  expect(cvsEl.style.cursor).toBe("");
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousemove', 0, 0));
+  expect(cvsEl.style.cursor).toBe('');
 
-  cvsEl.dispatchEvent(crtMSEvt4Offset("mousemove", 20, 20));
-  expect(cvsEl.style.cursor).toBe("move");
+  cvsEl.dispatchEvent(crtMSEvt4Offset('mousemove', 20, 20));
+  expect(cvsEl.style.cursor).toBe('move');
 });
diff --git a/packages/av-canvas/src/__tests__/event-tool.test.ts b/packages/av-canvas/src/__tests__/event-tool.test.ts
@@ -1,27 +1,27 @@
-import { expect, test, vi } from "vitest";
-import { EventTool } from "../event-tool";
+import { expect, test, vi } from 'vitest';
+import { EventTool } from '../event-tool';
 
-test("event-tool", () => {
+test('event-tool', () => {
   const evtTool = new EventTool<{
     a: (str: string) => void;
     b: () => void;
   }>();
 
   const onA = vi.fn();
   const onB = vi.fn();
-  evtTool.on("a", onA);
-  const offB = evtTool.on("b", onB);
+  evtTool.on('a', onA);
+  const offB = evtTool.on('b', onB);
   offB();
 
-  evtTool.emit("a", "test");
-  evtTool.emit("b");
+  evtTool.emit('a', 'test');
+  evtTool.emit('b');
 
-  expect(onA).toBeCalledWith("test");
+  expect(onA).toBeCalledWith('test');
   expect(onB).not.toBeCalled();
 
   onA.mockClear();
   evtTool.destroy();
 
-  evtTool.emit("a", "test");
+  evtTool.emit('a', 'test');
   expect(onA).not.toBeCalled();
 });