@serwist/core 8.4.3 → 9.0.0-preview.0

package/src/models/messages/messages.ts

@@ -0,0 +1,231 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+interface LoggableObject {
+  [key: string]: string | number;
+}
+interface MessageMap {
+  [messageID: string]: (param: LoggableObject) => string;
+}
+
+export const messages: MessageMap = {
+  "invalid-value": ({ paramName, validValueDescription, value }) => {
+    if (!paramName || !validValueDescription) {
+      throw new Error(`Unexpected input to 'invalid-value' error.`);
+    }
+    return (
+      `The '${paramName}' parameter was given a value with an ` +
+      `unexpected value. ${validValueDescription} Received a value of ` +
+      `${JSON.stringify(value)}.`
+    );
+  },
+
+  "not-an-array": ({ moduleName, className, funcName, paramName }) => {
+    if (!moduleName || !className || !funcName || !paramName) {
+      throw new Error(`Unexpected input to 'not-an-array' error.`);
+    }
+    return `The parameter '${paramName}' passed into ` + `'${moduleName}.${className}.${funcName}()' must be an array.`;
+  },
+
+  "incorrect-type": ({ expectedType, paramName, moduleName, className, funcName }) => {
+    if (!expectedType || !paramName || !moduleName || !funcName) {
+      throw new Error(`Unexpected input to 'incorrect-type' error.`);
+    }
+    const classNameStr = className ? `${className}.` : "";
+    return `The parameter '${paramName}' passed into ` + `'${moduleName}.${classNameStr}` + `${funcName}()' must be of type ${expectedType}.`;
+  },
+
+  "incorrect-class": ({ expectedClassName, paramName, moduleName, className, funcName, isReturnValueProblem }) => {
+    if (!expectedClassName || !moduleName || !funcName) {
+      throw new Error(`Unexpected input to 'incorrect-class' error.`);
+    }
+    const classNameStr = className ? `${className}.` : "";
+    if (isReturnValueProblem) {
+      return `The return value from '${moduleName}.${classNameStr}${funcName}()' must be an instance of class ${expectedClassName}.`;
+    }
+
+    return (
+      `The parameter '${paramName}' passed into ` +
+      `'${moduleName}.${classNameStr}${funcName}()' ` +
+      `must be an instance of class ${expectedClassName}.`
+    );
+  },
+
+  "missing-a-method": ({ expectedMethod, paramName, moduleName, className, funcName }) => {
+    if (!expectedMethod || !paramName || !moduleName || !className || !funcName) {
+      throw new Error(`Unexpected input to 'missing-a-method' error.`);
+    }
+    return `${moduleName}.${className}.${funcName}() expected the ` + `'${paramName}' parameter to expose a '${expectedMethod}' method.`;
+  },
+
+  "add-to-cache-list-unexpected-type": ({ entry }) => {
+    return `An unexpected entry was passed to '@serwist/precaching.PrecacheController.addToCacheList()' The entry '${JSON.stringify(
+      entry,
+    )}' isn't supported. You must supply an array of strings with one or more characters, objects with a url property or Request objects.`;
+  },
+
+  "add-to-cache-list-conflicting-entries": ({ firstEntry, secondEntry }) => {
+    if (!firstEntry || !secondEntry) {
+      throw new Error("Unexpected input to " + `'add-to-cache-list-duplicate-entries' error.`);
+    }
+
+    return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${firstEntry} but different revision details. Serwist is unable to cache and version the asset correctly. Please remove one of the entries.`;
+  },
+
+  "plugin-error-request-will-fetch": ({ thrownErrorMessage }) => {
+    if (!thrownErrorMessage) {
+      throw new Error("Unexpected input to " + `'plugin-error-request-will-fetch', error.`);
+    }
+
+    return `An error was thrown by a plugins 'requestWillFetch()' method. The thrown error message was: '${thrownErrorMessage}'.`;
+  },
+
+  "invalid-cache-name": ({ cacheNameId, value }) => {
+    if (!cacheNameId) {
+      throw new Error(`Expected a 'cacheNameId' for error 'invalid-cache-name'`);
+    }
+
+    return `You must provide a name containing at least one character for setCacheDetails({${cacheNameId}: '...'}). Received a value of '${JSON.stringify(
+      value,
+    )}'`;
+  },
+
+  "unregister-route-but-not-found-with-method": ({ method }) => {
+    if (!method) {
+      throw new Error("Unexpected input to " + `'unregister-route-but-not-found-with-method' error.`);
+    }
+
+    return `The route you're trying to unregister was not  previously registered for the method type '${method}'.`;
+  },
+
+  "unregister-route-route-not-registered": () => {
+    return `The route you're trying to unregister was not previously ` + "registered.";
+  },
+
+  "queue-replay-failed": ({ name }) => {
+    return `Replaying the background sync queue '${name}' failed.`;
+  },
+
+  "duplicate-queue-name": ({ name }) => {
+    return `The Queue name '${name}' is already being used. All instances of backgroundSync.Queue must be given unique names.`;
+  },
+
+  "expired-test-without-max-age": ({ methodName, paramName }) => {
+    return `The '${methodName}()' method can only be used when the ` + `'${paramName}' is used in the constructor.`;
+  },
+
+  "unsupported-route-type": ({ moduleName, className, funcName, paramName }) => {
+    return `The supplied '${paramName}' parameter was an unsupported type. Please check the docs for ${moduleName}.${className}.${funcName} for valid input types.`;
+  },
+
+  "not-array-of-class": ({ value, expectedClass, moduleName, className, funcName, paramName }) => {
+    return `The supplied '${paramName}' parameter must be an array of '${expectedClass}' objects. Received '${JSON.stringify(
+      value,
+    )},'. Please check the call to ${moduleName}.${className}.${funcName}() to fix the issue.`;
+  },
+
+  "max-entries-or-age-required": ({ moduleName, className, funcName }) => {
+    return `You must define either config.maxEntries or config.maxAgeSecondsin ${moduleName}.${className}.${funcName}`;
+  },
+
+  "statuses-or-headers-required": ({ moduleName, className, funcName }) => {
+    return `You must define either config.statuses or config.headersin ${moduleName}.${className}.${funcName}`;
+  },
+
+  "invalid-string": ({ moduleName, funcName, paramName }) => {
+    if (!paramName || !moduleName || !funcName) {
+      throw new Error(`Unexpected input to 'invalid-string' error.`);
+    }
+    return `When using strings, the '${paramName}' parameter must start with 'http' (for cross-origin matches) or '/' (for same-origin matches). Please see the docs for ${moduleName}.${funcName}() for more info.`;
+  },
+
+  "channel-name-required": () => {
+    return "You must provide a channelName to construct a " + "BroadcastCacheUpdate instance.";
+  },
+
+  "invalid-responses-are-same-args": () => {
+    return "The arguments passed into responsesAreSame() appear to be " + "invalid. Please ensure valid Responses are used.";
+  },
+
+  "expire-custom-caches-only": () => {
+    return `You must provide a 'cacheName' property when using the ` + "expiration plugin with a runtime caching strategy.";
+  },
+
+  "unit-must-be-bytes": ({ normalizedRangeHeader }) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'unit-must-be-bytes' error.`);
+    }
+    return `The 'unit' portion of the Range header must be set to 'bytes'. The Range header provided was "${normalizedRangeHeader}"`;
+  },
+
+  "single-range-only": ({ normalizedRangeHeader }) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'single-range-only' error.`);
+    }
+    return `Multiple ranges are not supported. Please use a  single start value, and optional end value. The Range header provided was "${normalizedRangeHeader}"`;
+  },
+
+  "invalid-range-values": ({ normalizedRangeHeader }) => {
+    if (!normalizedRangeHeader) {
+      throw new Error(`Unexpected input to 'invalid-range-values' error.`);
+    }
+    return `The Range header is missing both start and end values. At least one of those values is needed. The Range header provided was "${normalizedRangeHeader}"`;
+  },
+
+  "no-range-header": () => {
+    return "No Range header was found in the Request provided.";
+  },
+
+  "range-not-satisfiable": ({ size, start, end }) => {
+    return `The start (${start}) and end (${end}) values in the Range are ` + `not satisfiable by the cached response, which is ${size} bytes.`;
+  },
+
+  "attempt-to-cache-non-get-request": ({ url, method }) => {
+    return `Unable to cache '${url}' because it is a '${method}' request and only 'GET' requests can be cached.`;
+  },
+
+  "cache-put-with-no-response": ({ url }) => {
+    return `There was an attempt to cache '${url}' but the response was not defined.`;
+  },
+
+  "no-response": ({ url, error }) => {
+    let message = `The strategy could not generate a response for '${url}'.`;
+    if (error) {
+      message += ` The underlying error is ${error}.`;
+    }
+    return message;
+  },
+
+  "bad-precaching-response": ({ url, status }) => {
+    return `The precaching request for '${url}' failed${status ? ` with an HTTP status of ${status}.` : "."}`;
+  },
+
+  "non-precached-url": ({ url }) => {
+    return `createHandlerBoundToURL('${url}') was called, but that URL is not precached. Please pass in a URL that is precached instead.`;
+  },
+
+  "add-to-cache-list-conflicting-integrities": ({ url }) => {
+    return `Two of the entries passed to '@serwist/precaching.PrecacheController.addToCacheList()' had the URL ${url} with different integrity values. Please remove one of them.`;
+  },
+
+  "missing-precache-entry": ({ cacheName, url }) => {
+    return `Unable to find a precached response in ${cacheName} for ${url}.`;
+  },
+
+  "cross-origin-copy-response": ({ origin }) => {
+    return `@serwist/core.copyResponse() can only be used with same-origin responses. It was passed a response with origin ${origin}.`;
+  },
+
+  "opaque-streams-source": ({ type }) => {
+    const message = `One of the @serwist/streams sources resulted in an '${type}' response.`;
+    if (type === "opaqueredirect") {
+      return `${message} Please do not use a navigation request that results in a redirect as a source.`;
+    }
+    return `${message} Please ensure your sources are CORS-enabled.`;
+  },
+};

package/src/models/pluginEvents.ts

@@ -0,0 +1,17 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+export enum pluginEvents {
+  CACHE_DID_UPDATE = "cacheDidUpdate",
+  CACHE_KEY_WILL_BE_USED = "cacheKeyWillBeUsed",
+  CACHE_WILL_UPDATE = "cacheWillUpdate",
+  CACHED_RESPONSE_WILL_BE_USED = "cachedResponseWillBeUsed",
+  FETCH_DID_FAIL = "fetchDidFail",
+  FETCH_DID_SUCCEED = "fetchDidSucceed",
+  REQUEST_WILL_FETCH = "requestWillFetch",
+}

package/src/models/quotaErrorCallbacks.ts

@@ -0,0 +1,13 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+// Callbacks to be executed whenever there's a quota error.
+// biome-ignore lint/complexity/noBannedTypes: Can't change Function type right now.
+const quotaErrorCallbacks: Set<Function> = new Set();
+
+export { quotaErrorCallbacks };

package/src/registerQuotaErrorCallback.ts

@@ -0,0 +1,36 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { assert } from "./_private/assert.js";
+import { logger } from "./_private/logger.js";
+import { quotaErrorCallbacks } from "./models/quotaErrorCallbacks.js";
+
+/**
+ * Adds a function to the set of quotaErrorCallbacks that will be executed if
+ * there's a quota error.
+ *
+ * @param callback
+ */
+// biome-ignore lint/complexity/noBannedTypes: Can't change Function type
+function registerQuotaErrorCallback(callback: Function): void {
+  if (process.env.NODE_ENV !== "production") {
+    assert!.isType(callback, "function", {
+      moduleName: "@serwist/core",
+      funcName: "register",
+      paramName: "callback",
+    });
+  }
+
+  quotaErrorCallbacks.add(callback);
+
+  if (process.env.NODE_ENV !== "production") {
+    logger.log("Registered a callback to respond to quota errors.", callback);
+  }
+}
+
+export { registerQuotaErrorCallback };

package/src/setCacheNameDetails.ts

@@ -0,0 +1,55 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { SerwistError } from "./_private/SerwistError.js";
+import { assert } from "./_private/assert.js";
+import type { PartialCacheNameDetails } from "./_private/cacheNames.js";
+import { cacheNames } from "./_private/cacheNames.js";
+
+/**
+ * Modifies the default cache names used by the Serwist packages.
+ * Cache names are generated as `<prefix>-<Cache Name>-<suffix>`.
+ *
+ * @param details
+ */
+function setCacheNameDetails(details: PartialCacheNameDetails): void {
+  if (process.env.NODE_ENV !== "production") {
+    for (const key of Object.keys(details)) {
+      assert!.isType(details[key], "string", {
+        moduleName: "@serwist/core",
+        funcName: "setCacheNameDetails",
+        paramName: `details.${key}`,
+      });
+    }
+
+    if (details.precache?.length === 0) {
+      throw new SerwistError("invalid-cache-name", {
+        cacheNameId: "precache",
+        value: details.precache,
+      });
+    }
+
+    if (details.runtime?.length === 0) {
+      throw new SerwistError("invalid-cache-name", {
+        cacheNameId: "runtime",
+        value: details.runtime,
+      });
+    }
+
+    if (details.googleAnalytics?.length === 0) {
+      throw new SerwistError("invalid-cache-name", {
+        cacheNameId: "googleAnalytics",
+        value: details.googleAnalytics,
+      });
+    }
+  }
+
+  cacheNames.updateDetails(details);
+}
+
+export { setCacheNameDetails };

package/src/types.ts

@@ -0,0 +1,315 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+export interface MapLikeObject {
+  [key: string]: any;
+}
+
+/**
+ * Using a plain `MapLikeObject` for now, but could extend/restrict this
+ * in the future.
+ */
+export type PluginState = MapLikeObject;
+
+/**
+ * Options passed to a `RouteMatchCallback` function.
+ */
+export interface RouteMatchCallbackOptions {
+  event: ExtendableEvent;
+  request: Request;
+  sameOrigin: boolean;
+  url: URL;
+}
+
+/**
+ * The "match" callback is used to determine if a `Route` should apply for a
+ * particular URL and request. When matching occurs in response to a fetch
+ * event from the client, the `event` object is also supplied. However, since
+ * the match callback can be invoked outside of a fetch event, matching logic
+ * should not assume the `event` object will always be available.
+ * If the match callback returns a truthy value, the matching route's
+ * `RouteHandlerCallback` will be invoked immediately. If the value returned
+ * is a non-empty array or object, that value will be set on the handler's
+ * `options.params` argument.
+ */
+export interface RouteMatchCallback {
+  (options: RouteMatchCallbackOptions): any;
+}
+
+/**
+ * Options passed to a `RouteHandlerCallback` function.
+ */
+export declare interface RouteHandlerCallbackOptions {
+  /**
+   * The event associated with the request.
+   */
+  event: ExtendableEvent;
+  /**
+   * A request to run this strategy for.
+   */
+  request: Request;
+  url: URL;
+  /**
+   * The return value from `@serwist/routing`'s `matchCallback` (if applicable).
+   */
+  params?: string[] | MapLikeObject;
+}
+/**
+ * Options passed to a `ManualHandlerCallback` function.
+ */
+export interface ManualHandlerCallbackOptions {
+  /**
+   * The event associated with the request.
+   */
+  event: ExtendableEvent;
+  /**
+   * A request to run this strategy for.
+   */
+  request: Request | string;
+}
+
+export type HandlerCallbackOptions = RouteHandlerCallbackOptions | ManualHandlerCallbackOptions;
+
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL/Request
+ * to a `Route` via its `RouteMatchCallback`. This handler callback should
+ * return a `Promise` that resolves with a `Response`.
+ *
+ * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * will be passed in as this handler's `options.params` argument.
+ */
+export interface RouteHandlerCallback {
+  (options: RouteHandlerCallbackOptions): Promise<Response>;
+}
+
+/**
+ * The "handler" callback is invoked whenever a `Router` matches a URL/Request
+ * to a `Route` via its `RouteMatchCallback`. This handler callback should
+ * return a `Promise` that resolves with a `Response`.
+ *
+ * If a non-empty array or object is returned by the `RouteMatchCallback` it
+ * will be passed in as this handler's `options.params` argument.
+ */
+export interface ManualHandlerCallback {
+  (options: ManualHandlerCallbackOptions): Promise<Response>;
+}
+
+/**
+ * An object with a `handle` method of type `RouteHandlerCallback`.
+ *
+ * A `Route` object can be created with either an `RouteHandlerCallback`
+ * function or this `RouteHandler` object. The benefit of the `RouteHandler`
+ * is it can be extended (as is done by the `@serwist/strategies` package).
+ */
+export interface RouteHandlerObject {
+  handle: RouteHandlerCallback;
+}
+
+/**
+ * Either a `RouteHandlerCallback` or a `RouteHandlerObject`.
+ * Most APIs in `@serwist/routing` that accept route handlers take either.
+ */
+export type RouteHandler = RouteHandlerCallback | RouteHandlerObject;
+
+export interface HandlerWillStartCallbackParam {
+  request: Request;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface HandlerWillStartCallback {
+  (param: HandlerWillStartCallbackParam): Promise<any>;
+}
+
+export interface CacheDidUpdateCallbackParam {
+  /**
+   * Name of the cache the responses belong to. This is included in the
+   * broadcast message.
+   */
+  cacheName: string;
+  /**
+   * Possibly updated response to compare.
+   */
+  newResponse: Response;
+  /**
+   * The `Request` object for the cached entry.
+   */
+  request: Request;
+  /**
+   * The event that triggered this possible cache update.
+   */
+  event: ExtendableEvent;
+  /**
+   * Cached response to compare.
+   */
+  oldResponse?: Response | null;
+  state?: PluginState;
+}
+
+export interface CacheDidUpdateCallback {
+  (param: CacheDidUpdateCallbackParam): Promise<any>;
+}
+
+export interface CacheKeyWillBeUsedCallbackParam {
+  mode: string;
+  request: Request;
+  event: ExtendableEvent;
+  params?: any;
+  state?: PluginState;
+}
+
+export interface CacheKeyWillBeUsedCallback {
+  (param: CacheKeyWillBeUsedCallbackParam): Promise<Request | string>;
+}
+
+export interface CacheWillUpdateCallbackParam {
+  request: Request;
+  response: Response;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface CacheWillUpdateCallback {
+  (param: CacheWillUpdateCallbackParam): Promise<any>;
+}
+
+export interface CachedResponseWillBeUsedCallbackParam {
+  /**
+   * Name of the cache the response is in.
+   */
+  cacheName: string;
+  /**
+   * The original request, which may or may not
+   * contain a Range: header.
+   */
+  request: Request;
+  /**
+   * The complete cached `Response` object that's been read
+   * from a cache and whose freshness should be checked.
+   */
+  cachedResponse?: Response;
+  event: ExtendableEvent;
+  matchOptions?: CacheQueryOptions;
+  state?: PluginState;
+}
+
+export interface CachedResponseWillBeUsedCallback {
+  (param: CachedResponseWillBeUsedCallbackParam): Promise<any>;
+}
+
+export interface FetchDidFailCallbackParam {
+  error: Error;
+  originalRequest: Request;
+  request: Request;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface FetchDidFailCallback {
+  (param: FetchDidFailCallbackParam): Promise<any>;
+}
+
+export interface FetchDidSucceedCallbackParam {
+  request: Request;
+  response: Response;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface FetchDidSucceedCallback {
+  (param: FetchDidSucceedCallbackParam): Promise<Response>;
+}
+
+export interface RequestWillFetchCallbackParam {
+  request: Request;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface RequestWillFetchCallback {
+  (param: RequestWillFetchCallbackParam): Promise<Request>;
+}
+
+export interface HandlerWillRespondCallbackParam {
+  request: Request;
+  response: Response;
+  event: ExtendableEvent;
+  state?: PluginState;
+}
+
+export interface HandlerWillRespondCallback {
+  (param: HandlerWillRespondCallbackParam): Promise<Response>;
+}
+
+export interface HandlerDidErrorCallbackParam {
+  request: Request;
+  event: ExtendableEvent;
+  error: Error;
+  state?: PluginState;
+}
+
+export interface HandlerDidErrorCallback {
+  (param: HandlerDidErrorCallbackParam): Promise<Response | undefined>;
+}
+
+export interface HandlerDidRespondCallbackParam {
+  request: Request;
+  event: ExtendableEvent;
+  response?: Response;
+  state?: PluginState;
+}
+
+export interface HandlerDidRespondCallback {
+  (param: HandlerDidRespondCallbackParam): Promise<any>;
+}
+
+export interface HandlerDidCompleteCallbackParam {
+  request: Request;
+  error?: Error;
+  event: ExtendableEvent;
+  response?: Response;
+  state?: PluginState;
+}
+
+export interface HandlerDidCompleteCallback {
+  (param: HandlerDidCompleteCallbackParam): Promise<any>;
+}
+
+/**
+ * An object with optional lifecycle callback properties for the fetch and
+ * cache operations.
+ */
+export declare interface SerwistPlugin {
+  cacheDidUpdate?: CacheDidUpdateCallback;
+  cachedResponseWillBeUsed?: CachedResponseWillBeUsedCallback;
+  cacheKeyWillBeUsed?: CacheKeyWillBeUsedCallback;
+  cacheWillUpdate?: CacheWillUpdateCallback;
+  fetchDidFail?: FetchDidFailCallback;
+  fetchDidSucceed?: FetchDidSucceedCallback;
+  handlerDidComplete?: HandlerDidCompleteCallback;
+  handlerDidError?: HandlerDidErrorCallback;
+  handlerDidRespond?: HandlerDidRespondCallback;
+  handlerWillRespond?: HandlerWillRespondCallback;
+  handlerWillStart?: HandlerWillStartCallback;
+  requestWillFetch?: RequestWillFetchCallback;
+}
+
+export interface SerwistPluginCallbackParam {
+  cacheDidUpdate: CacheDidUpdateCallbackParam;
+  cachedResponseWillBeUsed: CachedResponseWillBeUsedCallbackParam;
+  cacheKeyWillBeUsed: CacheKeyWillBeUsedCallbackParam;
+  cacheWillUpdate: CacheWillUpdateCallbackParam;
+  fetchDidFail: FetchDidFailCallbackParam;
+  fetchDidSucceed: FetchDidSucceedCallbackParam;
+  handlerDidComplete: HandlerDidCompleteCallbackParam;
+  handlerDidError: HandlerDidErrorCallbackParam;
+  handlerDidRespond: HandlerDidRespondCallbackParam;
+  handlerWillRespond: HandlerWillRespondCallbackParam;
+  handlerWillStart: HandlerWillStartCallbackParam;
+  requestWillFetch: RequestWillFetchCallbackParam;
+}

package/src/utils/pluginUtils.ts

@@ -0,0 +1,15 @@
+/*
+  Copyright 2018 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { SerwistPlugin } from "../types.js";
+
+export const pluginUtils = {
+  filter: (plugins: SerwistPlugin[], callbackName: string): SerwistPlugin[] => {
+    return plugins.filter((plugin) => callbackName in plugin);
+  },
+};