@jakubmazanec/zod-utils 1.0.0-11dd4a3

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@jakubmazanec/zod-utils",
+  "version": "1.0.0-11dd4a3",
+  "description": "Collection of Zod schemas and utilities.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jakubmazanec/js-tools",
+    "directory": "packages/zod-utils"
+  },
+  "license": "LGPL-3.0-only",
+  "author": "Jakub Mazanec <jakub@mazanec.dev>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": "./dist/main.js",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "swc src -d dist && tsc",
+    "clean": "del-cli dist *.tsbuildinfo",
+    "document": "typedoc --options typedoc.config.cjs",
+    "format": "prettier . --write --ignore-unknown --ignore-path ../../.prettierignore",
+    "lint": "eslint .",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --passWithNoTests",
+    "typecheck": "tsc --project tsconfig.typecheck.json"
+  },
+  "dependencies": {
+    "@jakubmazanec/ts-utils": "2.1.0-11dd4a3"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.5.0",
+    "@types/node": "^16.18.3",
+    "zod": "^3.19.1"
+  },
+  "peerDependencies": {
+    "zod": "^3.19.1"
+  },
+  "packageManager": "npm@8.19.4",
+  "engines": {
+    "node": ">=16.20.0"
+  }
+}

package/src/main.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './utils.js';

package/src/types/Json.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod';
+
+const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
+
+type Literal = z.infer<typeof literalSchema>;
+
+export const jsonSchema: z.ZodSchema<Json> = z.lazy(() =>
+  z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)]),
+);
+
+export type Json = Json[] | Literal | {[key: string]: Json};

package/src/types/PackageJson.ts

@@ -0,0 +1,294 @@
+import * as z from 'zod';
+
+const packageJsonFundingSchema = z.union([
+  z
+    .object({
+      type: z
+        .union([
+          z.enum([
+            'corporation',
+            'foundation',
+            'github',
+            'individual',
+            'opencollective',
+            'patreon',
+          ]),
+          z.string(),
+        ])
+        .optional(),
+      url: z.string(),
+    })
+    .strict(),
+  z.string(),
+]);
+
+const packageJsonPublishConfigSchema = z.intersection(
+  z.object({
+    access: z.enum(['public', 'restricted']).optional(),
+    registry: z.string().optional(),
+    tag: z.string().optional(),
+  }),
+  z.record(z.unknown()),
+);
+
+const packageJsonPersonSchema = z.union([
+  z
+    .object({
+      name: z.string(),
+      email: z.string().optional(),
+      url: z.string().optional(),
+    })
+    .strict(),
+  z.string(),
+]);
+
+const packageJsonBugsLocationSchema = z.union([
+  z
+    .object({
+      email: z.string().optional(),
+      url: z.string().optional(),
+    })
+    .strict(),
+  z.string(),
+]);
+
+const packageJsonDirectoryLocationsSchema = z
+  .object({
+    bin: z.string().optional(),
+    doc: z.string().optional(),
+    example: z.string().optional(),
+    lib: z.string().optional(),
+    man: z.string().optional(),
+    v: z.string().optional(),
+  })
+  .strict();
+
+const packageJsonScriptsSchema = z.intersection(
+  z.record(z.string()),
+  z.object({
+    prepublish: z.string().optional(),
+    prepare: z.string().optional(),
+    prepublishOnly: z.string().optional(),
+    prepack: z.string().optional(),
+    postpack: z.string().optional(),
+    publish: z.string().optional(),
+    postpublish: z.string().optional(),
+    preinstall: z.string().optional(),
+    install: z.string().optional(),
+    postinstall: z.string().optional(),
+    preuninstall: z.string().optional(),
+    uninstall: z.string().optional(),
+    postuninstall: z.string().optional(),
+    preversion: z.string().optional(),
+    version: z.string().optional(),
+    postversion: z.string().optional(),
+    pretest: z.string().optional(),
+    test: z.string().optional(),
+    posttest: z.string().optional(),
+    prestop: z.string().optional(),
+    stop: z.string().optional(),
+    poststop: z.string().optional(),
+    prestart: z.string().optional(),
+    start: z.string().optional(),
+    poststart: z.string().optional(),
+    prerestart: z.string().optional(),
+    restart: z.string().optional(),
+    postrestart: z.string().optional(),
+  }),
+);
+
+const packageJsonDependenciesSchema = z.record(z.string());
+
+const packageJsonExportConditionSchema = z.union([
+  z.enum([
+    'browser',
+    'default',
+    'deno',
+    'development',
+    'electron',
+    'import',
+    'node',
+    'production',
+    'react-native',
+    'require',
+  ]),
+  z.string(),
+]);
+
+type PackageJsonExportCondition = z.infer<typeof packageJsonExportConditionSchema>;
+
+const packageJsonExportsSchema: z.ZodSchema<PackageJsonExports> = z.lazy(() =>
+  z.union([
+    z.string().array(),
+    z.string(),
+    z.object({
+      browser: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      default: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      deno: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      development: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      electron: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      import: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      node: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      production: z.union([packageJsonExportsSchema, z.null()]).optional(),
+      'react-native': z.union([packageJsonExportsSchema, z.null()]).optional(),
+      require: z.union([packageJsonExportsSchema, z.null()]).optional(),
+    }),
+    z.record(z.union([packageJsonExportsSchema, z.null()])),
+  ]),
+);
+
+const packageJsonBundledDependenciesSchema = z.union([z.string().array(), z.boolean()]).optional();
+
+type PackageJsonExports =
+  | string[]
+  | string
+  | {
+      [key in PackageJsonExportCondition]?: PackageJsonExports | null;
+    }
+  | {[key: string]: PackageJsonExports | null | undefined};
+
+export const packageJsonSchema = z.object({
+  name: z.string().optional(),
+  version: z.string().optional(),
+  description: z.string().optional(),
+  keywords: z.string().array().optional(),
+  homepage: z.string().optional(),
+  bugs: packageJsonBugsLocationSchema.optional(),
+  license: z.string().optional(),
+  author: packageJsonPersonSchema.optional(),
+  contributors: packageJsonPersonSchema.array().optional(),
+  maintainers: packageJsonPersonSchema.array().optional(),
+  files: z.string().array().optional(),
+  type: z.union([z.literal('commonjs'), z.literal('module')]).optional(),
+  main: z.string().optional(),
+  exports: packageJsonExportsSchema.optional(),
+  bin: z.union([z.record(z.string()), z.string()]).optional(),
+  man: z.union([z.string().array(), z.string()]).optional(),
+  directories: packageJsonDirectoryLocationsSchema.optional(),
+  repository: z
+    .union([
+      z
+        .object({
+          type: z.string(),
+          url: z.string(),
+          directory: z.string().optional(),
+        })
+        .strict(),
+      z.string(),
+    ])
+    .optional(),
+  scripts: packageJsonScriptsSchema.optional(),
+  config: z.record(z.unknown()).optional(),
+  dependencies: packageJsonDependenciesSchema.optional(),
+  devDependencies: packageJsonDependenciesSchema.optional(),
+  optionalDependencies: packageJsonDependenciesSchema.optional(),
+  peerDependencies: packageJsonDependenciesSchema.optional(),
+  peerDependenciesMeta: z
+    .record(
+      z.object({
+        optional: z.boolean(),
+      }),
+    )
+    .optional(),
+  bundledDependencies: packageJsonBundledDependenciesSchema,
+  bundleDependencies: packageJsonBundledDependenciesSchema,
+  overrides: z
+    .record(z.union([z.string(), z.record(z.union([z.string(), z.record(z.unknown())]))]))
+    .optional(),
+
+  funding: z.union([packageJsonFundingSchema.array(), packageJsonFundingSchema]).optional(),
+
+  module: z.string().optional(),
+  esnext: z.union([z.string(), z.record(z.string())]).optional(),
+  browser: z.union([z.string(), z.record(z.union([z.string(), z.literal(false)]))]).optional(),
+  sideEffects: z.union([z.string().array(), z.boolean()]).optional(),
+
+  engines: z
+    .intersection(
+      z.object({
+        node: z.string().optional(),
+        npm: z.string().optional(),
+      }),
+      z.record(z.string()),
+    )
+    .optional(),
+
+  os: z
+    .union([
+      z.enum([
+        '!aix',
+        '!darwin',
+        '!freebsd',
+        '!linux',
+        '!openbsd',
+        '!sunos',
+        '!win32',
+        'aix',
+        'darwin',
+        'freebsd',
+        'linux',
+        'openbsd',
+        'sunos',
+        'win32',
+      ]),
+      z.string(),
+    ])
+    .array()
+    .optional(),
+  cpu: z
+    .union([
+      z.enum([
+        '!arm',
+        '!arm64',
+        '!ia32',
+        '!mips',
+        '!mipsel',
+        '!ppc',
+        '!ppc64',
+        '!s390',
+        '!s390x',
+        '!x32',
+        '!x64',
+        'arm',
+        'arm64',
+        'ia32',
+        'mips',
+        'mipsel',
+        'ppc',
+        'ppc64',
+        's390',
+        's390x',
+        'x32',
+        'x64',
+      ]),
+      z.string(),
+    ])
+    .array()
+    .optional(),
+  private: z.boolean().optional(),
+  publishConfig: packageJsonPublishConfigSchema.optional(),
+  preferGlobal: z.boolean().optional(),
+
+  workspaces: z
+    .union([
+      z.string().array(),
+      z
+        .object({
+          packages: z.string().array().optional(),
+          nohoist: z.string().array().optional(),
+        })
+        .strict(),
+    ])
+    .optional(),
+  flat: z.boolean().optional(),
+  resolutions: packageJsonDependenciesSchema.optional(),
+
+  types: z.string().optional(),
+  typings: z.string().optional(),
+
+  // TODO: move following to separate schema
+  packageManager: z.string().optional(),
+  source: z.string().optional(),
+});
+
+export type PackageJson = z.infer<typeof packageJsonSchema>;

package/src/types/TsconfigJson.ts

@@ -0,0 +1,346 @@
+import * as z from 'zod';
+
+let jsxSchema = z.enum(['preserve', 'react', 'react-jsx', 'react-jsxdev', 'react-native']);
+
+let moduleSchema = z.enum([
+  'CommonJS',
+  'AMD',
+  'System',
+  'UMD',
+  'ES6',
+  'ES2015',
+  'ES2020',
+  'ESNext',
+  'None',
+  'commonjs',
+  'amd',
+  'system',
+  'umd',
+  'es6',
+  'es2015',
+  'es2020',
+  'esnext',
+  'none',
+]);
+
+let newLineSchema = z.enum(['CRLF', 'LF', 'crlf', 'lf']);
+
+let targetSchema = z.enum([
+  'ES3',
+  'ES5',
+  'ES6',
+  'ES2015',
+  'ES2016',
+  'ES2017',
+  'ES2018',
+  'ES2019',
+  'ES2020',
+  'ES2021',
+  'ESNext',
+  'es3',
+  'es5',
+  'es6',
+  'es2015',
+  'es2016',
+  'es2017',
+  'es2018',
+  'es2019',
+  'es2020',
+  'es2021',
+  'esnext',
+]);
+
+let libSchema = z.enum([
+  'ES5',
+  'ES6',
+  'ES7',
+  'ES2015',
+  'ES2015.Collection',
+  'ES2015.Core',
+  'ES2015.Generator',
+  'ES2015.Iterable',
+  'ES2015.Promise',
+  'ES2015.Proxy',
+  'ES2015.Reflect',
+  'ES2015.Symbol.WellKnown',
+  'ES2015.Symbol',
+  'ES2016',
+  'ES2016.Array.Include',
+  'ES2017',
+  'ES2017.Intl',
+  'ES2017.Object',
+  'ES2017.SharedMemory',
+  'ES2017.String',
+  'ES2017.TypedArrays',
+  'ES2018',
+  'ES2018.AsyncGenerator',
+  'ES2018.AsyncIterable',
+  'ES2018.Intl',
+  'ES2018.Promise',
+  'ES2018.Regexp',
+  'ES2019',
+  'ES2019.Array',
+  'ES2019.Object',
+  'ES2019.String',
+  'ES2019.Symbol',
+  'ES2020',
+  'ES2020.BigInt',
+  'ES2020.Promise',
+  'ES2020.String',
+  'ES2020.Symbol.WellKnown',
+  'ES2020.SharedMemory',
+  'ES2020.Intl',
+  'ES2021',
+  'ES2021.Promise',
+  'ES2021.String',
+  'ES2021.WeakRef',
+  'ESNext',
+  'ESNext.Array',
+  'ESNext.AsyncIterable',
+  'ESNext.BigInt',
+  'ESNext.Intl',
+  'ESNext.Promise',
+  'ESNext.String',
+  'ESNext.Symbol',
+  'ESNext.WeakRef',
+  'DOM',
+  'DOM.Iterable',
+  'ScriptHost',
+  'WebWorker',
+  'WebWorker.ImportScripts',
+  'WebWorker.Iterable',
+  'es5',
+  'es6',
+  'es7',
+  'es2015',
+  'es2015.collection',
+  'es2015.core',
+  'es2015.generator',
+  'es2015.iterable',
+  'es2015.promise',
+  'es2015.proxy',
+  'es2015.reflect',
+  'es2015.symbol.wellknown',
+  'es2015.symbol',
+  'es2016',
+  'es2016.array.include',
+  'es2017',
+  'es2017.intl',
+  'es2017.object',
+  'es2017.sharedmemory',
+  'es2017.string',
+  'es2017.typedarrays',
+  'es2018',
+  'es2018.asyncgenerator',
+  'es2018.asynciterable',
+  'es2018.intl',
+  'es2018.promise',
+  'es2018.regexp',
+  'es2019',
+  'es2019.array',
+  'es2019.object',
+  'es2019.string',
+  'es2019.symbol',
+  'es2020',
+  'es2020.bigint',
+  'es2020.promise',
+  'es2020.string',
+  'es2020.symbol.wellknown',
+  'es2020.sharedmemory',
+  'es2020.intl',
+  'es2021',
+  'es2021.promise',
+  'es2021.string',
+  'es2021.weakref',
+  'esnext',
+  'esnext.array',
+  'esnext.asynciterable',
+  'esnext.bigint',
+  'esnext.intl',
+  'esnext.promise',
+  'esnext.string',
+  'esnext.symbol',
+  'esnext.weakref',
+  'dom',
+  'dom.iterable',
+  'scripthost',
+  'webworker',
+  'webworker.importscripts',
+  'webworker.iterable',
+]);
+
+let pluginSchema = z
+  .object({
+    name: z.string().optional(),
+  })
+  .strict()
+  .and(z.record(z.unknown()));
+
+let importsNotUsedAsValuesSchema = z.enum(['remove', 'preserve', 'error']);
+
+let fallbackPollingSchema = z.enum([
+  'fixedPollingInterval',
+  'priorityPollingInterval',
+  'dynamicPriorityPolling',
+  'fixedInterval',
+  'priorityInterval',
+  'dynamicPriority',
+  'fixedChunkSize',
+]);
+
+let watchDirectory = z.enum([
+  'useFsEvents',
+  'fixedPollingInterval',
+  'dynamicPriorityPolling',
+  'fixedChunkSizePolling',
+]);
+
+let watchFileSchema = z.enum([
+  'fixedPollingInterval',
+  'priorityPollingInterval',
+  'dynamicPriorityPolling',
+  'useFsEvents',
+  'useFsEventsOnParentDirectory',
+  'fixedChunkSizePolling',
+]);
+
+let compilerOptionsSchema = z
+  .object({
+    allowJs: z.boolean().optional(),
+    allowSyntheticDefaultImports: z.boolean().optional(),
+    allowUmdGlobalAccess: z.boolean().optional(),
+    allowUnreachableCode: z.boolean().optional(),
+    allowUnusedLabels: z.boolean().optional(),
+    alwaysStrict: z.boolean().optional(),
+    assumeChangesOnlyAffectDirectDependencies: z.boolean().optional(),
+    baseUrl: z.string().optional(),
+    charset: z.string().optional(),
+    checkJs: z.boolean().optional(),
+    composite: z.boolean().optional(),
+    declaration: z.boolean().optional(),
+    declarationDir: z.string().optional(),
+    declarationMap: z.boolean().optional(),
+    diagnostics: z.boolean().optional(),
+    disableReferencedProjectLoad: z.boolean().optional(),
+    disableSizeLimit: z.boolean().optional(),
+    disableSolutionSearching: z.boolean().optional(),
+    disableSourceOfProjectReferenceRedirect: z.boolean().optional(),
+    downlevelIteration: z.boolean().optional(),
+    emitBOM: z.boolean().optional(),
+    emitDeclarationOnly: z.boolean().optional(),
+    emitDecoratorMetadata: z.boolean().optional(),
+    esModuleInterop: z.boolean().optional(),
+    exactOptionalPropertyTypes: z.boolean().optional(),
+    experimentalDecorators: z.boolean().optional(),
+    explainFiles: z.boolean().optional(),
+    extendedDiagnostics: z.boolean().optional(),
+    fallbackPolling: fallbackPollingSchema.optional(),
+    forceConsistentCasingInFileNames: z.boolean().optional(),
+    generateCpuProfile: z.string().optional(),
+    importHelpers: z.boolean().optional(),
+    importsNotUsedAsValues: importsNotUsedAsValuesSchema.optional(),
+    incremental: z.boolean().optional(),
+    inlineSourceMap: z.boolean().optional(),
+    inlineSources: z.boolean().optional(),
+    isolatedModules: z.boolean().optional(),
+    jsx: jsxSchema.optional(),
+    jsxFactory: z.string().optional(),
+    jsxFragmentFactory: z.string().optional(),
+    jsxImportSource: z.string().optional(),
+    keyofStringsOnly: z.boolean().optional(),
+    lib: libSchema.array().optional(),
+    listEmittedFiles: z.boolean().optional(),
+    listFiles: z.boolean().optional(),
+    listFilesOnly: z.boolean().optional(),
+    mapRoot: z.string().optional(),
+    maxNodeModuleJsDepth: z.number().optional(),
+    module: moduleSchema.optional(),
+    moduleResolution: z.enum(['classic', 'node']).optional(),
+    newLine: newLineSchema.optional(),
+    noEmit: z.boolean().optional(),
+    noEmitHelpers: z.boolean().optional(),
+    noEmitOnError: z.boolean().optional(),
+    noErrorTruncation: z.boolean().optional(),
+    noFallthroughCasesInSwitch: z.boolean().optional(),
+    noImplicitAny: z.boolean().optional(),
+    noImplicitOverride: z.boolean().optional(),
+    noImplicitReturns: z.boolean().optional(),
+    noImplicitThis: z.boolean().optional(),
+    noImplicitUseStrict: z.boolean().optional(),
+    noLib: z.boolean().optional(),
+    noPropertyAccessFromIndexSignature: z.boolean().optional(),
+    noResolve: z.boolean().optional(),
+    noStrictGenericChecks: z.boolean().optional(),
+    noUncheckedIndexedAccess: z.boolean().optional(),
+    noUnusedLocals: z.boolean().optional(),
+    noUnusedParameters: z.boolean().optional(),
+    outDir: z.string().optional(),
+    outFile: z.string().optional(),
+    paths: z.record(z.string().array()).optional(),
+    plugins: pluginSchema.array().optional(),
+    preserveConstEnums: z.boolean().optional(),
+    preserveSymlinks: z.boolean().optional(),
+    preserveWatchOutput: z.boolean().optional(),
+    pretty: z.boolean().optional(),
+    reactNamespace: z.string().optional(),
+    removeComments: z.boolean().optional(),
+    resolveJsonModule: z.boolean().optional(),
+    rootDir: z.string().optional(),
+    rootDirs: z.string().array().optional(),
+    skipDefaultLibCheck: z.boolean().optional(),
+    skipLibCheck: z.boolean().optional(),
+    sourceMap: z.boolean().optional(),
+    sourceRoot: z.string().optional(),
+    strict: z.boolean().optional(),
+    strictBindCallApply: z.boolean().optional(),
+    strictFunctionTypes: z.boolean().optional(),
+    strictNullChecks: z.boolean().optional(),
+    strictPropertyInitialization: z.boolean().optional(),
+    stripInternal: z.boolean().optional(),
+    suppressExcessPropertyErrors: z.boolean().optional(),
+    suppressImplicitAnyIndexErrors: z.boolean().optional(),
+    target: targetSchema.optional(),
+    traceResolution: z.boolean().optional(),
+    tsBuildInfoFile: z.string().optional(),
+    typeRoots: z.string().array().optional(),
+    types: z.string().array().optional(),
+    useDefineForClassFields: z.boolean().optional(),
+    useUnknownInCatchVariables: z.boolean().optional(),
+    watch: z.boolean().optional(),
+    watchDirectory: watchDirectory.optional(),
+    watchFile: watchFileSchema.optional(),
+  })
+  .strict();
+
+let typeAcquisitionSchema = z
+  .object({
+    enable: z.boolean().optional(),
+    include: z.string().array().optional(),
+    exclude: z.string().array().optional(),
+  })
+  .strict();
+
+let referencesSchema = z
+  .object({
+    path: z.string(),
+
+    originalPath: z.string().optional(),
+    prepend: z.boolean().optional(),
+    circular: z.boolean().optional(),
+  })
+  .strict();
+
+export const tsconfigJsonSchema = z
+  .object({
+    compileOnSave: z.boolean().optional(),
+    compilerOptions: compilerOptionsSchema.optional(),
+    exclude: z.string().array().optional(),
+    extends: z.string().optional(),
+    files: z.string().array().optional(),
+    include: z.string().array().optional(),
+    references: referencesSchema.array().optional(),
+    typeAcquisition: typeAcquisitionSchema.optional(),
+  })
+  .strict();
+
+export type TsconfigJson = z.infer<typeof tsconfigJsonSchema>;

package/src/types.ts

@@ -0,0 +1,3 @@
+export * from './types/Json.js';
+export * from './types/PackageJson.js';
+export * from './types/TsconfigJson.js';

package/src/utils/is.ts

@@ -0,0 +1,5 @@
+import {type z, type ZodTypeAny} from 'zod';
+
+export function is<S extends ZodTypeAny>(value: unknown, schema: S): value is z.infer<S> {
+  return schema.safeParse(value).success;
+}