@serwist/build 8.4.4 → 9.0.0-preview.1

package/src/lib/validate-options.ts

@@ -0,0 +1,47 @@
+/*
+  Copyright 2021 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 { validationErrorMap } from "../schema/validationErrorMap.js";
+import type {
+  GetManifestOptionsComplete,
+  InjectManifestOptionsComplete,
+  ViteInjectManifestOptionsComplete,
+  WebpackInjectManifestOptionsComplete,
+} from "../types.js";
+import { SerwistConfigError } from "./serwist-config-error.js";
+
+export const validateGetManifestOptions = async (input: unknown): Promise<GetManifestOptionsComplete> => {
+  const result = await (await import("../schema/getManifest.js")).getManifestOptions.spa(input, { errorMap: validationErrorMap });
+  if (!result.success) {
+    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+  }
+  return result.data;
+};
+
+export const validateInjectManifestOptions = async (input: unknown): Promise<InjectManifestOptionsComplete> => {
+  const result = await (await import("../schema/injectManifest.js")).injectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  if (!result.success) {
+    throw new SerwistConfigError({ moduleName: "@serwist/build", message: JSON.stringify(result.error.format(), null, 2) });
+  }
+  return result.data;
+};
+
+export const validateWebpackInjectManifestOptions = async (input: unknown): Promise<WebpackInjectManifestOptionsComplete> => {
+  const result = await (await import("../schema/webpack.js")).webpackInjectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  if (!result.success) {
+    throw new SerwistConfigError({ moduleName: "@serwist/webpack-plugin", message: JSON.stringify(result.error.format(), null, 2) });
+  }
+  return result.data;
+};
+
+export const validateViteInjectManifestOptions = async (input: unknown): Promise<ViteInjectManifestOptionsComplete> => {
+  const result = await (await import("../schema/vite.js")).viteInjectManifestOptions.spa(input, { errorMap: validationErrorMap });
+  if (!result.success) {
+    throw new SerwistConfigError({ moduleName: "@serwist/vite", message: JSON.stringify(result.error.format(), null, 2) });
+  }
+  return result.data;
+};

package/src/schema/assertType.ts

@@ -0,0 +1,5 @@
+export type Equals<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false;
+
+export function assertType<_T extends true>() {
+  // Do nothing
+}

package/src/schema/base.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+import type { BasePartial, BaseResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { manifestEntry } from "./manifestEntry.js";
+import { manifestTransform } from "./manifestTransform.js";
+
+export const basePartial = z
+  .object({
+    additionalPrecacheEntries: z.array(z.union([z.string(), manifestEntry])).optional(),
+    disablePrecacheManifest: z.boolean().default(false),
+    dontCacheBustURLsMatching: z.instanceof(RegExp).optional(),
+    manifestTransforms: z.array(manifestTransform).optional(),
+    maximumFileSizeToCacheInBytes: z.number().default(2097152),
+    modifyURLPrefix: z.record(z.string(), z.string()).optional(),
+  })
+  .strict("Do not pass invalid properties to BasePartial!");
+
+assertType<Equals<BasePartial, z.input<typeof basePartial>>>();
+assertType<Equals<BaseResolved, z.output<typeof basePartial>>>();

package/src/schema/getManifest.ts

@@ -0,0 +1,13 @@
+import type { z } from "zod";
+import type { GetManifestOptions, GetManifestOptionsComplete } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { basePartial } from "./base.js";
+import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
+
+export const getManifestOptions = basePartial
+  .merge(globPartial)
+  .merge(requiredGlobDirectoryPartial)
+  .strict("Do not pass invalid properties to GetManifestOptions!");
+
+assertType<Equals<GetManifestOptions, z.input<typeof getManifestOptions>>>();
+assertType<Equals<GetManifestOptionsComplete, z.output<typeof getManifestOptions>>>();

package/src/schema/glob.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type {
+  GlobPartial,
+  GlobResolved,
+  OptionalGlobDirectoryPartial,
+  OptionalGlobDirectoryResolved,
+  RequiredGlobDirectoryPartial,
+  RequiredGlobDirectoryResolved,
+} from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+
+export const globPartial = z
+  .object({
+    globFollow: z.boolean().default(true),
+    globIgnores: z.array(z.string()).default(["**/node_modules/**/*"]),
+    globPatterns: z.array(z.string()).default(["**/*.{js,css,html}"]),
+    globStrict: z.boolean().default(true),
+    templatedURLs: z.record(z.string(), z.union([z.string(), z.array(z.string())])).optional(),
+  })
+  .strict("Do not pass invalid properties to GlobPartial!");
+
+export const optionalGlobDirectoryPartial = z
+  .object({
+    globDirectory: z.string().optional(),
+  })
+  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!");
+
+// This needs to be set when using GetManifest or InjectManifest. This is
+// enforced via runtime validation, and needs to be documented.
+export const requiredGlobDirectoryPartial = z
+  .object({
+    globDirectory: z.string(),
+  })
+  .strict("Do not pass invalid properties to RequiredGlobDirectoryPartial!");
+
+assertType<Equals<GlobPartial, z.input<typeof globPartial>>>();
+assertType<Equals<GlobResolved, z.output<typeof globPartial>>>();
+assertType<Equals<OptionalGlobDirectoryPartial, z.input<typeof optionalGlobDirectoryPartial>>>();
+assertType<Equals<OptionalGlobDirectoryResolved, z.output<typeof optionalGlobDirectoryPartial>>>();
+assertType<Equals<RequiredGlobDirectoryPartial, z.input<typeof requiredGlobDirectoryPartial>>>();
+assertType<Equals<RequiredGlobDirectoryResolved, z.output<typeof requiredGlobDirectoryPartial>>>();

package/src/schema/injectManifest.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, InjectPartial, InjectResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { basePartial } from "./base.js";
+import { globPartial, requiredGlobDirectoryPartial } from "./glob.js";
+import { requiredSwDestPartial } from "./swDest.js";
+
+export const injectPartial = z
+  .object({
+    injectionPoint: z.string().default("self.__SW_MANIFEST"),
+    swSrc: z.string(),
+  })
+  .strict("Do not pass invalid properties to InjectPartial!");
+
+export const injectManifestOptions = basePartial
+  .merge(globPartial)
+  .merge(injectPartial)
+  .merge(requiredSwDestPartial)
+  .merge(requiredGlobDirectoryPartial)
+  .strict("Do not pass invalid properties to InjectManifestOptions!");
+
+assertType<Equals<InjectPartial, z.input<typeof injectPartial>>>();
+assertType<Equals<InjectResolved, z.output<typeof injectPartial>>>();
+assertType<Equals<InjectManifestOptions, z.input<typeof injectManifestOptions>>>();
+assertType<Equals<InjectManifestOptionsComplete, z.output<typeof injectManifestOptions>>>();

package/src/schema/manifestEntry.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const manifestEntry = z
+  .object({
+    integrity: z.string().optional(),
+    revision: z.string().nullable(),
+    url: z.string(),
+  })
+  .strict("Do not pass invalid properties to ManifestEntry!");

package/src/schema/manifestTransform.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+import { manifestEntry } from "./manifestEntry.js";
+
+export const manifestTransformResult = z
+  .object({
+    manifest: z.array(manifestEntry.merge(z.object({ size: z.number() }))),
+    warnings: z.array(z.string()).optional(),
+  })
+  .strict("Do not pass invalid properties to ManifestTransformResult!");
+
+export const manifestTransform = z.function(
+  z.tuple([z.array(manifestEntry.merge(z.object({ size: z.number() }))), z.unknown().optional()]),
+  z.union([z.promise(manifestTransformResult), manifestTransformResult]),
+);

package/src/schema/next.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import type {
+  NextInjectManifestOptions,
+  NextInjectManifestOptionsComplete,
+  NextInjectManifestPartial,
+  NextInjectManifestResolved,
+} from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { requiredSwDestPartial } from "./swDest.js";
+import { webpackInjectManifestOptions } from "./webpack.js";
+
+export const nextInjectManifestPartial = z
+  .object({
+    cacheOnNavigation: z.boolean().default(false),
+    disable: z.boolean().default(false),
+    register: z.boolean().default(true),
+    reloadOnOnline: z.boolean().default(true),
+    scope: z.string().optional(),
+    swUrl: z.string().default("/sw.js"),
+    globPublicPatterns: z.union([z.string(), z.array(z.string())]).default(["**/*"]),
+  })
+  .strict("Do not pass invalid properties to NextInjectManifestPartial!");
+
+export const nextInjectManifestOptions = webpackInjectManifestOptions
+  .merge(requiredSwDestPartial)
+  .merge(nextInjectManifestPartial)
+  .omit({ disablePrecacheManifest: true })
+  .strict("Do not pass invalid properties to NextInjectManifestOptions!");
+
+assertType<Equals<NextInjectManifestPartial, z.input<typeof nextInjectManifestPartial>>>();
+assertType<Equals<NextInjectManifestResolved, z.output<typeof nextInjectManifestPartial>>>();
+assertType<Equals<NextInjectManifestOptions, z.input<typeof nextInjectManifestOptions>>>();
+assertType<Equals<NextInjectManifestOptionsComplete, z.output<typeof nextInjectManifestOptions>>>();

package/src/schema/swDest.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import type { OptionalSwDestPartial, OptionalSwDestResolved, RequiredSwDestPartial, RequiredSwDestResolved } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+
+export const optionalSwDestPartial = z
+  .object({
+    swDest: z.string().optional(),
+  })
+  .strict("Do not pass invalid properties to OptionalSwDest!");
+
+export const requiredSwDestPartial = z
+  .object({
+    swDest: z.string(),
+  })
+  .strict("Do not pass invalid properties to RequiredSwDest!");
+
+assertType<Equals<OptionalSwDestPartial, z.input<typeof optionalSwDestPartial>>>();
+assertType<Equals<OptionalSwDestResolved, z.output<typeof optionalSwDestPartial>>>();
+assertType<Equals<RequiredSwDestPartial, z.input<typeof requiredSwDestPartial>>>();
+assertType<Equals<RequiredSwDestResolved, z.output<typeof requiredSwDestPartial>>>();

package/src/schema/validationErrorMap.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+export const validationErrorMap: z.ZodErrorMap = (error, ctx) => {
+  /*
+    This is where you override the various error codes
+    */
+  switch (error.code) {
+    case z.ZodIssueCode.invalid_type: {
+      return { message: `${error.message ?? "Received invalid type"}: expected ${error.expected}, received ${error.received}.` };
+    }
+    case z.ZodIssueCode.invalid_literal: {
+      return { message: `${error.message ?? "Received invalid literal"}: expected ${error.expected}, received ${error.received}.` };
+    }
+    case z.ZodIssueCode.unrecognized_keys: {
+      return { message: `${error.message ?? "Received unrecognized keys"}: ${error.keys.join(",")}` };
+    }
+    case z.ZodIssueCode.invalid_arguments: {
+      return {
+        message: `${error.message ?? "Received invalid arguments"}: ${error.argumentsError.errors.map((e) => validationErrorMap(e, ctx)).join(",")}.`,
+      };
+    }
+    case z.ZodIssueCode.invalid_return_type: {
+      return {
+        message: `${error.message ?? "Received invalid return type"}: ${error.returnTypeError.errors
+          .map((e) => validationErrorMap(e, ctx))
+          .join(",")}.`,
+      };
+    }
+    case z.ZodIssueCode.custom: {
+      return { message: error.message ?? ctx.defaultError };
+    }
+  }
+
+  // Fallback to the default message.
+  return { message: ctx.defaultError };
+};

package/src/schema/vite.ts

@@ -0,0 +1,18 @@
+import type { z } from "zod";
+import type { ViteInjectManifestOptions, ViteInjectManifestOptionsComplete } from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { basePartial } from "./base.js";
+import { globPartial } from "./glob.js";
+import { requiredGlobDirectoryPartial } from "./glob.js";
+import { injectPartial } from "./injectManifest.js";
+import { requiredSwDestPartial } from "./swDest.js";
+
+export const viteInjectManifestOptions = basePartial
+  .merge(globPartial)
+  .merge(injectPartial)
+  .merge(requiredSwDestPartial)
+  .merge(requiredGlobDirectoryPartial)
+  .strict("Do not pass invalid properties to ViteInjectManifestPartial!");
+
+assertType<Equals<ViteInjectManifestOptions, z.input<typeof viteInjectManifestOptions>>>();
+assertType<Equals<ViteInjectManifestOptionsComplete, z.output<typeof viteInjectManifestOptions>>>();

package/src/schema/webpack.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import type {
+  WebpackInjectManifestOptions,
+  WebpackInjectManifestOptionsComplete,
+  WebpackInjectManifestPartial,
+  WebpackInjectManifestResolved,
+  WebpackPartial,
+  WebpackResolved,
+} from "../types.js";
+import { type Equals, assertType } from "./assertType.js";
+import { basePartial } from "./base.js";
+import { injectPartial } from "./injectManifest.js";
+import { optionalSwDestPartial } from "./swDest.js";
+
+export const webpackPartial = z
+  .object({
+    chunks: z.array(z.string()).optional(),
+    exclude: z
+      .array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())]))
+      .default([/\.map$/, /^manifest.*\.js$/]),
+    excludeChunks: z.array(z.string()).optional(),
+    include: z.array(z.union([z.string(), z.instanceof(RegExp), z.function(z.tuple([z.any()]), z.boolean())])).optional(),
+    mode: z.string().nullable().optional(),
+  })
+  .strict("Do not pass invalid properties to WebpackPartial!");
+
+export const webpackInjectManifestPartial = z
+  .object({
+    compileSrc: z.boolean().default(true),
+    swDest: z.string().optional(),
+    webpackCompilationPlugins: z.array(z.any()).optional(),
+  })
+  .strict("Do not pass invalid properties to WebpackInjectManifestPartial!");
+
+export const webpackInjectManifestOptions = basePartial
+  .merge(webpackPartial)
+  .merge(injectPartial)
+  .merge(optionalSwDestPartial)
+  .merge(webpackInjectManifestPartial)
+  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!");
+
+assertType<Equals<WebpackPartial, z.input<typeof webpackPartial>>>();
+assertType<Equals<WebpackResolved, z.output<typeof webpackPartial>>>();
+assertType<Equals<WebpackInjectManifestPartial, z.input<typeof webpackInjectManifestPartial>>>();
+assertType<Equals<WebpackInjectManifestResolved, z.output<typeof webpackInjectManifestPartial>>>();
+assertType<Equals<WebpackInjectManifestOptions, z.input<typeof webpackInjectManifestOptions>>>();
+assertType<Equals<WebpackInjectManifestOptionsComplete, z.output<typeof webpackInjectManifestOptions>>>();