@serwist/build 8.4.3 → 9.0.0-preview.0

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/base.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+import type { BasePartial, BaseResolved } from "../types.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!") satisfies z.ZodType<BaseResolved, z.ZodObjectDef, BasePartial>;

package/src/schema/getManifest.ts

@@ -0,0 +1,14 @@
+import type { z } from "zod";
+
+import type { GetManifestOptions, GetManifestOptionsComplete } from "../types.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!") satisfies z.ZodType<
+  GetManifestOptionsComplete,
+  z.ZodObjectDef,
+  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";
+
+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!") satisfies z.ZodType<GlobResolved, z.ZodObjectDef, GlobPartial>;
+
+export const optionalGlobDirectoryPartial = z
+  .object({
+    globDirectory: z.string().optional(),
+  })
+  .strict("Do not pass invalid properties to OptionalGlobDirectoryPartial!") satisfies z.ZodType<
+  OptionalGlobDirectoryResolved,
+  z.ZodObjectDef,
+  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!") satisfies z.ZodType<
+  RequiredGlobDirectoryResolved,
+  z.ZodObjectDef,
+  RequiredGlobDirectoryPartial
+>;

package/src/schema/injectManifest.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import type { InjectManifestOptions, InjectManifestOptionsComplete, InjectPartial, InjectResolved } from "../types.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!") satisfies z.ZodType<InjectResolved, z.ZodObjectDef, InjectPartial>;
+
+export const injectManifestOptions = basePartial
+  .merge(globPartial)
+  .merge(injectPartial)
+  .merge(requiredSwDestPartial)
+  .merge(requiredGlobDirectoryPartial)
+  .strict("Do not pass invalid properties to InjectManifestOptions!") satisfies z.ZodType<
+  InjectManifestOptionsComplete,
+  z.ZodObjectDef,
+  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,35 @@
+import { z } from "zod";
+import type {
+  NextInjectManifestOptions,
+  NextInjectManifestOptionsComplete,
+  NextInjectManifestPartial,
+  NextInjectManifestResolved,
+} from "../types.js";
+import { requiredSwDestPartial } from "./swDest.js";
+import { webpackInjectManifestOptions } from "./webpack.js";
+
+export const nextInjectManifestPartial = z
+  .object({
+    cacheOnFrontEndNav: 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.array(z.string()).default(["**/*"]),
+  })
+  .strict("Do not pass invalid properties to NextInjectManifestPartial!") satisfies z.ZodType<
+  NextInjectManifestResolved,
+  z.ZodObjectDef,
+  NextInjectManifestPartial
+>;
+
+export const nextInjectManifestOptions = webpackInjectManifestOptions
+  .merge(requiredSwDestPartial)
+  .merge(nextInjectManifestPartial)
+  .omit({ disablePrecacheManifest: true })
+  .strict("Do not pass invalid properties to NextInjectManifestOptions!") satisfies z.ZodType<
+  NextInjectManifestOptionsComplete,
+  z.ZodObjectDef,
+  NextInjectManifestOptions
+>;

package/src/schema/swDest.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import type { OptionalSwDestPartial, OptionalSwDestResolved, RequiredSwDestPartial, RequiredSwDestResolved } from "../types.js";
+
+export const optionalSwDestPartial = z
+  .object({
+    swDest: z.string().optional(),
+  })
+  .strict("Do not pass invalid properties to OptionalSwDest!") satisfies z.ZodType<OptionalSwDestResolved, z.ZodObjectDef, OptionalSwDestPartial>;
+
+export const requiredSwDestPartial = z
+  .object({
+    swDest: z.string(),
+  })
+  .strict("Do not pass invalid properties to RequiredSwDest!") satisfies z.ZodType<RequiredSwDestResolved, z.ZodObjectDef, 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 { 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!") satisfies z.ZodType<
+  ViteInjectManifestOptionsComplete,
+  z.ZodObjectDef,
+  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 { 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!") satisfies z.ZodType<WebpackResolved, z.ZodObjectDef, 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!") satisfies z.ZodType<
+  WebpackInjectManifestResolved,
+  z.ZodObjectDef,
+  WebpackInjectManifestPartial
+>;
+
+export const webpackInjectManifestOptions = basePartial
+  .merge(webpackPartial)
+  .merge(injectPartial)
+  .merge(optionalSwDestPartial)
+  .merge(webpackInjectManifestPartial)
+  .strict("Do not pass invalid properties to WebpackInjectManifestOptions!") satisfies z.ZodType<
+  WebpackInjectManifestOptionsComplete,
+  z.ZodObjectDef,
+  WebpackInjectManifestOptions
+>;