@weser/schema 0.0.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-present Robin Weser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# @weser/context
+
+<img alt="npm version" src="https://badge.fury.io/js/@weser%2Fcontext.svg"> <img alt="npm downloads" src="https://img.shields.io/npm/dm/@weser/context.svg"> <a href="https://bundlephobia.com/result?p=@weser/context@latest"><img alt="Bundlephobia" src="https://img.shields.io/bundlephobia/minzip/@weser/context.svg"></a>
+
+## Installation
+
+```sh
+# npm
+npm i --save @weser/context
+# yarn
+yarn add @weser/context
+# pnpm
+pnpm add @weser/context
+```
+
+## Documentation
+
+### `createContext<T>`
+
+#### Parameters
+
+| Parameter    | Type      | Default | Description                                              |
+| ------------ | --------- | ------- | -------------------------------------------------------- |
+| defaultValue | `T`       | `null`  | The default value for when no provider is used           |
+| name         |  `string` | `""`    | (Optional) A name for the context used in error messages |
+
+```tsx
+import { createContext } from '@weser/context'
+
+type Theme = 'light' | 'dark'
+
+const [useTheme, ThemeProvider] = createContext<Theme>('light', 'theme')
+
+function App({ children }) {
+  return <ThemeProvider value="dark">{children}</ThemeProvider>
+}
+
+function Component() {
+  const theme = useTheme()
+
+  return (
+    <div style={{ backgroundColor: theme === 'dark' ? 'black' : 'white' }}>
+      Hello
+    </div>
+  )
+}
+```
+
+## License
+
+@weser/context is licensed under the [MIT License](http://opensource.org/licenses/MIT).<br>
+Documentation is licensed under [Creative Common License](http://creativecommons.org/licenses/by/4.0/).<br>
+Created with ♥ by [@robinweser](http://weser.io).

package/dist/builders.d.ts

@@ -0,0 +1,33 @@
+import { T_JSONSchemaEnum, T_JSONSchemaString, T_JSONSchemaNumber, T_JSONSchemaBoolean, T_JSONSchemaArray, T_JSONSchemaObject, T_JSONSchema } from './types.js';
+export declare function createEnumSchema(values: ReadonlyArray<string>, options?: {
+    description?: string;
+    default?: string;
+}): T_JSONSchemaEnum;
+export declare function createStringSchema(options?: {
+    minLength?: number;
+    maxLength?: number;
+    format?: 'date' | 'uri';
+    description?: string;
+    default?: string;
+}): T_JSONSchemaString;
+export declare function createNumberSchema(options?: {
+    minimum?: number;
+    maximum?: number;
+    description?: string;
+    default?: number;
+}): T_JSONSchemaNumber;
+export declare function createBooleanSchema(options?: {
+    description?: string;
+    default?: boolean;
+}): T_JSONSchemaBoolean;
+export declare function createArraySchema<T>(items: T_JSONSchema, options?: {
+    description?: string;
+    default?: Array<T>;
+}): T_JSONSchemaArray<T>;
+export declare function createObjectSchema<T extends Record<string, any>>(properties: {
+    [K in keyof T]: T_JSONSchema;
+}, options?: {
+    required?: Array<keyof T>;
+    description?: string;
+    default?: T;
+}): T_JSONSchemaObject<T>;

package/dist/builders.js

@@ -0,0 +1,18 @@
+export function createEnumSchema(values, options = {}) {
+    return { enum: [...values], ...options };
+}
+export function createStringSchema(options = {}) {
+    return { type: 'string', ...options };
+}
+export function createNumberSchema(options = {}) {
+    return { type: 'number', ...options };
+}
+export function createBooleanSchema(options = {}) {
+    return { type: 'boolean', ...options };
+}
+export function createArraySchema(items, options = {}) {
+    return { type: 'array', items, ...options };
+}
+export function createObjectSchema(properties, options = {}) {
+    return { type: 'object', properties, ...options };
+}

package/dist/fromZod.d.ts

@@ -0,0 +1,3 @@
+import { ZodType } from 'zod';
+import { T_JSONSchema } from './types.js';
+export default function fromZod(schema: ZodType): T_JSONSchema;

package/dist/fromZod.js

@@ -0,0 +1,4 @@
+import z from 'zod';
+export default function fromZod(schema) {
+    return z.toJSONSchema(schema);
+}

package/dist/guards.d.ts

@@ -0,0 +1,7 @@
+import { T_JSONSchema, T_JSONSchemaBoolean, T_JSONSchemaEnum, T_JSONSchemaNumber, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchemaString } from './types.js';
+export declare function isEnumSchema(schema: T_JSONSchema): schema is T_JSONSchemaEnum;
+export declare function isStringSchema(schema: T_JSONSchema): schema is T_JSONSchemaString;
+export declare function isNumberSchema(schema: T_JSONSchema): schema is T_JSONSchemaNumber;
+export declare function isBooleanSchema(schema: T_JSONSchema): schema is T_JSONSchemaBoolean;
+export declare function isObjectSchema(schema: T_JSONSchema): schema is T_JSONSchemaObject;
+export declare function isArraySchema(schema: T_JSONSchema): schema is T_JSONSchemaArray;

package/dist/guards.js

@@ -0,0 +1,18 @@
+export function isEnumSchema(schema) {
+    return schema.enum !== undefined;
+}
+export function isStringSchema(schema) {
+    return schema.type === 'string';
+}
+export function isNumberSchema(schema) {
+    return schema.type === 'number';
+}
+export function isBooleanSchema(schema) {
+    return schema.type === 'boolean';
+}
+export function isObjectSchema(schema) {
+    return schema.type === 'object';
+}
+export function isArraySchema(schema) {
+    return schema.type === 'array';
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { default as fromZod } from './fromZod.js';
+export { default as toZod } from './toZod.js';
+export * from './toZod.js';
+export * from './guards.js';
+export * from './types.js';
+export * from './validators.js';
+export * from './builders.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { default as fromZod } from './fromZod.js';
+export { default as toZod } from './toZod.js';
+export * from './toZod.js';
+export * from './guards.js';
+export * from './types.js';
+export * from './validators.js';
+export * from './builders.js';

package/dist/toZod.d.ts

@@ -0,0 +1,21 @@
+import z from 'zod';
+import { T_JSONSchema, T_JSONSchemaBoolean, T_JSONSchemaEnum, T_JSONSchemaNumber, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchemaString } from './types.js';
+export default function toZod(schema: T_JSONSchema): z.ZodEnum<{
+    [x: string]: string;
+}> | z.ZodDefault<z.ZodEnum<{
+    [x: string]: string;
+}>> | z.ZodString | z.ZodDefault<z.ZodString> | z.ZodNumber | z.ZodDefault<z.ZodNumber> | z.ZodBoolean | z.ZodDefault<z.ZodBoolean> | z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown>;
+}, {}, {}> | z.ZodArray<z.ZodAny> | z.ZodDefault<z.ZodArray<z.ZodAny>>;
+export declare function toZodString({ minLength, maxLength, description, default: _default, format, ...meta }: T_JSONSchemaString): z.ZodString | z.ZodDefault<z.ZodString>;
+export declare function toZodEnum({ enum: _enum, description, default: _default, ...meta }: T_JSONSchemaEnum): z.ZodEnum<{
+    [x: string]: string;
+}> | z.ZodDefault<z.ZodEnum<{
+    [x: string]: string;
+}>>;
+export declare function toZodNumber({ minimum, maximum, description, default: _default, ...meta }: T_JSONSchemaNumber): z.ZodNumber | z.ZodDefault<z.ZodNumber>;
+export declare function toZodBoolean({ description, default: _default, ...meta }: T_JSONSchemaBoolean): z.ZodBoolean | z.ZodDefault<z.ZodBoolean>;
+export declare function toZodObject({ properties, required, description, ...meta }: T_JSONSchemaObject): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown>;
+}, {}, {}>;
+export declare function toZodArray({ items, description, default: _default, ...meta }: T_JSONSchemaArray): z.ZodArray<z.ZodAny> | z.ZodDefault<z.ZodArray<z.ZodAny>>;

package/dist/toZod.js

@@ -0,0 +1,111 @@
+import z from 'zod';
+import { isBooleanSchema, isEnumSchema, isNumberSchema, isObjectSchema, isArraySchema, isStringSchema, } from './guards.js';
+export default function toZod(schema) {
+    if (isEnumSchema(schema)) {
+        return toZodEnum(schema);
+    }
+    if (isStringSchema(schema)) {
+        return toZodString(schema);
+    }
+    if (isNumberSchema(schema)) {
+        return toZodNumber(schema);
+    }
+    if (isBooleanSchema(schema)) {
+        return toZodBoolean(schema);
+    }
+    if (isObjectSchema(schema)) {
+        return toZodObject(schema);
+    }
+    if (isArraySchema(schema)) {
+        return toZodArray(schema);
+    }
+    throw new Error('Error converting JSON schema to Zod type.');
+}
+export function toZodString({ minLength, maxLength, description, default: _default, format, ...meta }) {
+    let type = z.string();
+    if (format === 'uri') {
+        type = type.url();
+    }
+    else if (format === 'date') {
+        type = type.date();
+    }
+    type = type.meta({ ...meta, ...(format ? { format } : {}) });
+    if (description) {
+        type = type.describe(description);
+    }
+    if (minLength) {
+        type = type.min(minLength);
+    }
+    if (maxLength) {
+        type = type.max(maxLength);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodEnum({ enum: _enum, description, default: _default, ...meta }) {
+    let type = z.enum(_enum);
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodNumber({ minimum, maximum, description, default: _default, ...meta }) {
+    let type = z.number();
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (minimum) {
+        type = type.min(minimum);
+    }
+    if (maximum) {
+        type = type.max(maximum);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodBoolean({ description, default: _default, ...meta }) {
+    let type = z.boolean();
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodObject({ properties, required, description, ...meta }) {
+    const props = Object.entries(properties).reduce((props, [property, schema]) => {
+        const type = toZod(schema);
+        if (type) {
+            props[property] = type;
+        }
+        return props;
+    }, {});
+    let type = z.object(props);
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    return type;
+}
+export function toZodArray({ items, description, default: _default, ...meta }) {
+    let type = z.array(toZod(items));
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/builders.ts","../src/fromzod.ts","../src/guards.ts","../src/index.ts","../src/tozod.ts","../src/types.ts","../src/validators.ts"],"version":"5.9.2"}

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+export type T_JSONValue = string | number | boolean | null | JSONObject | Array<T_JSONValue>;
+export type JSONObject = {
+    [key: string]: T_JSONValue;
+};
+export type T_JSONSchemaRaw = {
+    description?: string;
+    [key: string]: any;
+};
+export type T_JSONSchemaEnum = T_JSONSchemaRaw & {
+    enum: Array<string>;
+    default?: string;
+};
+export type T_JSONSchemaString = T_JSONSchemaRaw & {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    format?: 'date' | 'uri';
+    default?: string;
+};
+export type T_JSONSchemaNumber = T_JSONSchemaRaw & {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    default?: number;
+};
+export type T_JSONSchemaBoolean = T_JSONSchemaRaw & {
+    type: 'boolean';
+    default?: boolean;
+};
+export interface T_JSONSchemaArray<T = T_JSONValue> extends T_JSONSchemaRaw {
+    type: 'array';
+    items: T_JSONSchema;
+    default?: Array<T>;
+}
+export interface T_JSONSchemaObject<T extends Record<string, any> = Record<string, T_JSONValue>> extends T_JSONSchemaRaw {
+    type: 'object';
+    required?: Array<keyof T>;
+    properties: Record<string, T_JSONSchema>;
+    default?: T;
+}
+export type T_JSONSchema = T_JSONSchemaEnum | T_JSONSchemaString | T_JSONSchemaNumber | T_JSONSchemaBoolean | T_JSONSchemaObject | T_JSONSchemaArray;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validators.d.ts

@@ -0,0 +1,8 @@
+import { T_JSONSchemaEnum, T_JSONSchemaString, T_JSONSchemaNumber, T_JSONSchemaBoolean, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchema } from './types.js';
+export declare function isValidEnumSchema(schema: T_JSONSchema): schema is T_JSONSchemaEnum;
+export declare function isValidStringSchema(schema: T_JSONSchema): schema is T_JSONSchemaString;
+export declare function isValidNumberSchema(schema: T_JSONSchema): schema is T_JSONSchemaNumber;
+export declare function isValidBooleanSchema(schema: T_JSONSchema): schema is T_JSONSchemaBoolean;
+export declare function isValidArraySchema(schema: T_JSONSchema): schema is T_JSONSchemaArray;
+export declare function isValidObjectSchema(schema: T_JSONSchema): schema is T_JSONSchemaObject;
+export declare function isValidSchema(schema: T_JSONSchema): schema is T_JSONSchema;

package/dist/validators.js

@@ -0,0 +1,77 @@
+import z from 'zod';
+const enumValidator = z
+    .object({
+    enum: z.array(z.string()),
+    description: z.string().optional(),
+    default: z.string().optional(),
+})
+    .passthrough();
+export function isValidEnumSchema(schema) {
+    return enumValidator.safeParse(schema).success;
+}
+const stringValidator = z
+    .object({
+    type: z.literal('string'),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    format: z.enum(['date', 'uri']).optional(),
+    description: z.string().optional(),
+    default: z.string().optional(),
+})
+    .passthrough();
+export function isValidStringSchema(schema) {
+    return stringValidator.safeParse(schema).success;
+}
+const numberValidator = z
+    .object({
+    type: z.literal('number'),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    description: z.string().optional(),
+    default: z.number().optional(),
+})
+    .passthrough();
+export function isValidNumberSchema(schema) {
+    return numberValidator.safeParse(schema).success;
+}
+const booleanValidator = z
+    .object({
+    type: z.literal('boolean'),
+    description: z.string().optional(),
+    default: z.boolean().optional(),
+})
+    .passthrough();
+export function isValidBooleanSchema(schema) {
+    return booleanValidator.safeParse(schema).success;
+}
+const arrayValidator = z
+    .object({
+    type: z.literal('array'),
+    items: z.any(),
+    description: z.string().optional(),
+    default: z.array(z.any()).optional(),
+})
+    .passthrough();
+export function isValidArraySchema(schema) {
+    return arrayValidator.safeParse(schema).success;
+}
+const objectValidator = z
+    .object({
+    type: z.literal('object'),
+    properties: z.record(z.string(), z.any()),
+    required: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    default: z.record(z.string(), z.any()).optional(),
+})
+    .passthrough();
+export function isValidObjectSchema(schema) {
+    return objectValidator.safeParse(schema).success;
+}
+export function isValidSchema(schema) {
+    return (isValidEnumSchema(schema) ||
+        isValidStringSchema(schema) ||
+        isValidNumberSchema(schema) ||
+        isValidBooleanSchema(schema) ||
+        isValidObjectSchema(schema) ||
+        isValidArraySchema(schema));
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@weser/schema",
+  "version": "0.0.8",
+  "description": "Helpers for working with Zod and JSON Schema",
+  "author": "Robin Weser <robin@weser.io>",
+  "license": "MIT",
+  "homepage": "https://github.com/robinweser/weser.git",
+  "repository": "https://github.com/robinweser/weser.git",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist/**"
+  ],
+  "browserslist": [
+    "IE >= 11",
+    "Firefox >= 60",
+    "Safari >= 11.1",
+    "Chrome >= 66",
+    "ChromeAndroid >= 66",
+    "iOS >= 11.3",
+    "Edge >= 15"
+  ],
+  "scripts": {
+    "setup": "pnpm build",
+    "clean": "rimraf dist",
+    "build": "tsc -b",
+    "dev": "pnpm build -w",
+    "test": "ava"
+  },
+  "keywords": [
+    "zod",
+    "json-schema",
+    "schema",
+    "conversion",
+    "utils"
+  ],
+  "peerDependencies": {
+    "zod": "*"
+  },
+  "devDependencies": {
+    "ava": "^6.1.3",
+    "rimraf": "^3.0.2",
+    "typescript": "^5.4.5",
+    "zod": "4.0.0-beta.20250505T195954"
+  },
+  "gitHead": "9dce5f658f08431e80506b022369229dfeff7dd7"
+}