@gasboost/client 0.1.0

package/src/job/AppsScriptJobQueue.ts

@@ -0,0 +1,48 @@
+import { AppsScriptJob } from "./AppsScriptJob";
+
+export interface RunnableJob {
+  run(): Promise<void>;
+  addJob<T>(job: AppsScriptJob<T>): void;
+}
+
+export class AppsScriptJobQueue {
+  private jobs: AppsScriptJob<any>[] = [];
+  private listeners: Set<RunnableJob> = new Set();
+
+  public enqueue<T>(label: string, execute: () => Promise<T>): Promise<T> {
+    const promise = new Promise<T>((resolve, reject) => {
+      // キューにジョブを追加
+      const job = new AppsScriptJob<T>(label, execute, resolve, reject);
+      this.jobs.push(job);
+      this.notify(job);
+    });
+
+    return promise;
+  }
+
+  public dequeue(): AppsScriptJob<any> | undefined {
+    const job = this.jobs.shift();
+    if (!job) return undefined;
+    return job;
+  }
+
+  private notify<T>(job: AppsScriptJob<T>) {
+    this.listeners.forEach((listener) => {
+      listener.addJob(job);
+      listener.run();
+    });
+  }
+
+  public subscribe(listener: RunnableJob) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  remove(jobId: string) {
+    const index = this.jobs.findIndex((job) => job.id === jobId);
+
+    if (index !== -1) {
+      this.jobs.splice(index, 1);
+    }
+  }
+}

package/src/job/AppsScriptJobRunner.ts

@@ -0,0 +1,107 @@
+import { AppsScriptJob } from "./AppsScriptJob";
+import { AppsScriptJobQueue, RunnableJob } from "./AppsScriptJobQueue";
+
+export class AppsScriptJobRunner implements RunnableJob {
+  private jobs: AppsScriptJob<any>[] = [];
+  private listeners: Set<() => void> = new Set();
+  private MAX_CONCURRENT = 30;
+  private running = false;
+
+  private snapshot: AppsScriptJob<any>[] | null = null;
+  private dirty = true;
+
+  constructor(public readonly queue: AppsScriptJobQueue) {
+    this.queue.subscribe(this);
+  }
+
+  public addJob<T>(job: AppsScriptJob<T>) {
+    this.jobs.push(job);
+    this.notify();
+  }
+
+  public getJobs() {
+    if (this.dirty || !this.snapshot) {
+      this.snapshot = [...this.jobs];
+      this.dirty = false;
+    }
+    return this.snapshot;
+  }
+
+  public async run(): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+
+    while (true) {
+      const runningCount = this.jobs.filter((j) => j.isRunning()).length;
+
+      if (runningCount >= this.MAX_CONCURRENT) break;
+
+      const job = this.queue.dequeue();
+      if (!job) break;
+
+      job.start();
+      this.notify();
+
+      job
+        .execute()
+        .then((result) => {
+          job.success(result);
+          const index = this.jobs.indexOf(job);
+          if (index !== -1) {
+            this.jobs.splice(index, 1);
+          }
+        })
+        .catch((error) => {
+          job.fail(error);
+        })
+        .finally(() => {
+          this.notify();
+          this.running = false;
+          this.run();
+        });
+    }
+
+    this.running = false;
+  }
+
+  public remove(jobId: string) {
+    const index = this.jobs.findIndex((job) => job.id === jobId);
+
+    if (index === -1) {
+      return;
+    }
+
+    this.jobs.splice(index, 1);
+    this.notify();
+  }
+
+  public cancel(jobId: string) {
+    const job = this.jobs.find((job) => job.id === jobId);
+
+    if (!job || !job.cancel()) {
+      return;
+    }
+
+    this.queue.remove(jobId);
+    this.jobs.splice(this.jobs.indexOf(job), 1);
+    this.notify();
+  }
+
+  public retry(jobId: AppsScriptJob<any>["id"]) {
+    const job = this.jobs.find((j) => j.id === jobId);
+    if (job) {
+      this.remove(job.id);
+      this.queue.enqueue(job.label, job.execute);
+    }
+  }
+
+  public subscribe(listener: () => void) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notify() {
+    this.dirty = true;
+    this.listeners.forEach((listener) => listener());
+  }
+}

package/src/job/AppsScriptJobStore.ts

@@ -0,0 +1,16 @@
+import { AppsScriptJob } from "./AppsScriptJob";
+import { AppsScriptJobRunner } from "./AppsScriptJobRunner";
+
+export interface AppsScriptJobStore {
+  subscribe: (listener: () => void) => () => void;
+  getSnapshot: () => AppsScriptJob<any>[];
+}
+
+export function appsScriptJobStore(
+  runner: AppsScriptJobRunner,
+): AppsScriptJobStore {
+  return {
+    subscribe: runner.subscribe.bind(runner),
+    getSnapshot: runner.getJobs.bind(runner),
+  };
+}

package/src/navigation/AppsScriptContainer.ts

@@ -0,0 +1,47 @@
+import { google } from "../google";
+
+import { NavigationEntry } from "./NavigationEntry";
+
+export class AppsScriptContainer {
+  private constructor(private entry: NavigationEntry) {}
+
+  static load(callback: (container: AppsScriptContainer) => void) {
+    google.script.url.getLocation((location) => {
+      callback(new AppsScriptContainer(NavigationEntry.fromGoogle(location)));
+    });
+  }
+
+  observe(handler: (entry: NavigationEntry) => void) {
+    google.script.history.setChangeHandler((event) => {
+      const entry = NavigationEntry.fromGoogle(event);
+
+      this.entry = entry;
+
+      handler(entry);
+    });
+  }
+
+  sync(entry: NavigationEntry) {
+    if (this.entry.equals(entry)) {
+      return;
+    }
+
+    this.entry = entry;
+
+    const parameters: Record<string, string[]> = {};
+
+    for (const key of new Set(entry.location.searchParams.keys())) {
+      parameters[key] = entry.location.searchParams.getAll(key);
+    }
+
+    google.script.history.push(
+      entry.state,
+      parameters,
+      entry.location.hash.normalize(),
+    );
+  }
+
+  current() {
+    return this.entry;
+  }
+}

package/src/navigation/AppsScriptHistoryPipeline.ts

@@ -0,0 +1,29 @@
+import { AppsScriptContainer } from "./AppsScriptContainer";
+import { AppsScriptIframe } from "./AppsScriptIframe";
+
+export class AppsScriptHistoryPipeline {
+  constructor(
+    private readonly container: AppsScriptContainer,
+    private readonly iframe: AppsScriptIframe,
+  ) {}
+
+  static create(callback: (pipeline: AppsScriptHistoryPipeline) => void) {
+    AppsScriptContainer.load((container) => {
+      callback(
+        new AppsScriptHistoryPipeline(container, new AppsScriptIframe()),
+      );
+    });
+  }
+
+  sync() {
+    this.iframe.sync(this.container.current());
+
+    this.container.observe((entry) => {
+      this.iframe.sync(entry);
+    });
+
+    return this.iframe.observe((entry) => {
+      this.container.sync(entry);
+    });
+  }
+}

package/src/navigation/AppsScriptIframe.ts

@@ -0,0 +1,63 @@
+import { HashProperty } from "./HashProperty";
+import { NavigationEntry } from "./NavigationEntry";
+import { NavigationLocation } from "./NavigationLocation";
+
+export class AppsScriptIframe {
+  private entry: NavigationEntry;
+
+  constructor() {
+    this.entry = this.read();
+  }
+
+  observe(handler: (entry: NavigationEntry) => void) {
+    const listener = () => {
+      const entry = this.read();
+
+      this.entry = entry;
+
+      handler(entry);
+    };
+
+    window.addEventListener("hashchange", listener);
+    window.addEventListener("popstate", listener);
+
+    return () => {
+      window.removeEventListener("hashchange", listener);
+      window.removeEventListener("popstate", listener);
+    };
+  }
+
+  sync(entry: NavigationEntry) {
+    if (this.entry.equals(entry)) {
+      return;
+    }
+
+    const hash = entry.location.hash.normalize();
+    const search = entry.location.searchParams.toString();
+    const nextHash = search ? `${hash}?${search}` : hash;
+
+    history.replaceState(entry.state, "", nextHash);
+
+    this.entry = entry;
+  }
+
+  current() {
+    return this.entry;
+  }
+
+  private read() {
+    const normalized = new HashProperty(window.location.hash)
+      .toString()
+      .replace(/^#/, "");
+
+    const [path = "/", query = ""] = normalized.split("?");
+
+    return new NavigationEntry(
+      history.state ?? {},
+      new NavigationLocation(
+        new HashProperty(path),
+        new URLSearchParams(query),
+      ),
+    );
+  }
+}

package/src/navigation/HashProperty.ts

@@ -0,0 +1,20 @@
+export class HashProperty {
+  constructor(private readonly value: string) {}
+
+  normalize() {
+    if (!this.value) return "#/";
+    if (this.value.startsWith("#/")) return this.value;
+    if (this.value.startsWith("#")) return `#/${this.value.slice(1)}`;
+    if (this.value.startsWith("/")) return `#${this.value}`;
+
+    return `#/${this.value}`;
+  }
+
+  equals(other: HashProperty) {
+    return this.normalize() === other.normalize();
+  }
+
+  toString() {
+    return this.normalize();
+  }
+}

package/src/navigation/NavigationEntry.ts

@@ -0,0 +1,82 @@
+import type {
+  GoogleScriptHistoryEvent,
+  GoogleScriptUrlLocation,
+} from "../google";
+
+import { HashProperty } from "./HashProperty";
+import { NavigationLocation } from "./NavigationLocation";
+
+export class NavigationEntry {
+  constructor(
+    readonly state: Record<string, unknown>,
+    readonly location: NavigationLocation,
+  ) {}
+
+  static fromGoogle(
+    source: GoogleScriptHistoryEvent | GoogleScriptUrlLocation,
+  ) {
+    const location = "location" in source ? source.location : source;
+    const state = "state" in source ? source.state : {};
+
+    const searchParams = new URLSearchParams();
+
+    for (const [key, values] of Object.entries(location.parameters)) {
+      for (const value of values) {
+        searchParams.append(key, value);
+      }
+    }
+
+    return new NavigationEntry(
+      state,
+      new NavigationLocation(new HashProperty(location.hash), searchParams),
+    );
+  }
+
+  equals(other: NavigationEntry) {
+    const equalsState = (left: unknown, right: unknown): boolean => {
+      if (Object.is(left, right)) {
+        return true;
+      }
+
+      if (
+        typeof left !== "object" ||
+        left === null ||
+        typeof right !== "object" ||
+        right === null
+      ) {
+        return false;
+      }
+
+      if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right)) {
+          return false;
+        }
+
+        return (
+          left.length === right.length &&
+          left.every((value, index) => equalsState(value, right[index]))
+        );
+      }
+
+      const leftObject = left as Record<string, unknown>;
+      const rightObject = right as Record<string, unknown>;
+
+      const leftKeys = Object.keys(leftObject);
+      const rightKeys = Object.keys(rightObject);
+
+      return (
+        leftKeys.length === rightKeys.length &&
+        leftKeys.every(
+          (key) =>
+            Object.hasOwn(rightObject, key) &&
+            equalsState(leftObject[key], rightObject[key]),
+        )
+      );
+    };
+
+    return (
+      equalsState(this.state, other.state) &&
+      this.location.equals(other.location)
+    );
+  }
+}

package/src/navigation/NavigationLocation.ts

@@ -0,0 +1,54 @@
+import { HashProperty } from "./HashProperty";
+
+export class NavigationLocation {
+  constructor(
+    readonly hash: HashProperty,
+    readonly searchParams: URLSearchParams,
+  ) {}
+
+  equals(other: NavigationLocation) {
+    const thisHash = this.hash.normalize().split("?")[0];
+    const otherHash = other.hash.normalize().split("?")[0];
+
+    if (thisHash !== otherHash) {
+      return false;
+    }
+
+    const thisKeys = [...new Set(this.searchParams.keys())].sort();
+    const otherKeys = [...new Set(other.searchParams.keys())].sort();
+
+    if (thisKeys.length !== otherKeys.length) {
+      return false;
+    }
+
+    return thisKeys.every((key, index) => {
+      if (key !== otherKeys[index]) {
+        return false;
+      }
+
+      const thisValues = this.searchParams.getAll(key);
+      const otherValues = other.searchParams.getAll(key);
+
+      return (
+        thisValues.length === otherValues.length &&
+        thisValues.every(
+          (value, valueIndex) => value === otherValues[valueIndex],
+        )
+      );
+    });
+  }
+
+  private normalizeSearchParams(searchParams: URLSearchParams) {
+    const keys = [...new Set(searchParams.keys())].sort();
+
+    const normalized = new URLSearchParams();
+
+    for (const key of keys) {
+      for (const value of searchParams.getAll(key)) {
+        normalized.append(key, value);
+      }
+    }
+
+    return normalized.toString();
+  }
+}