zerde 0.1.0 → 0.1.2

package/README.md

@@ -3,27 +3,31 @@
 Typescript library for parsing and stringifying combined with schema validationg
 
 When stringifying or parsing an object, you want to verify that what you are stringifying or parsing matches a schema.
+
 This is the overall workflow:
+
 Parsing: stringifiedContent -> parse -> SomeObject
+
 Stringifying: SomeObject -> stringify -> stringifiedContent
 
 However, all type safety is lost during these steps (especially during the parse step)
 
 The desired workflow:
 
-Parsing: stringifiedContent<SomeType> -> parse -> Unknown -> validateIsSomeType -> SomeType
-Stringifying: SomeType -> validateIsSomeType -> stringify -> stringifiedContent<SomeType>
+Parsing: stringifiedContent\<SomeType\> -> parse -> Unknown -> validateIsSomeType -> SomeType
+
+Stringifying: SomeType -> validateIsSomeType -> stringify -> stringifiedContent\<SomeType\>
 
 This way, you are able to parse some unknown string into a strongly typed result, and ensure that the object you are about to stringify matches the intended schema
 
-The next step is each `parse`/`stringify` function is specific to one format. `JSON.parse`/`JSON.stringify` only handles `JSON`. What if you need to parse/stringify some other format? Import another library.
+However, each `parse`/`stringify` function is specific to one format. `JSON.parse`/`JSON.stringify` only handles `JSON`. What if you need to parse/stringify some other format? Import another library.
 
 This library provides a unified way to parse, stringify and validate:
 
-[x] JSON
-[] YAML (coming soon)
-[] TOML (coming soon)
-[] CSV (coming soon)
+- [x] JSON
+- [] YAML (coming soon)
+- [] TOML (coming soon)
+- [] CSV (coming soon)
 
 Makes use of [Standard Schema](https://github.com/standard-schema/standard-schema) to support all the popular schema libraries (Zod, Valibot, etc).
 
@@ -97,7 +101,7 @@ Handles a wide variety of string cases:
 | media type with charset | "application/customFormat+json; charset=utf-8" |
 
 
-When calling `zparse`, if the unknownContent was not a string, or if no format is specified, or if the specified format is not supported, `zparse` will not modify the passed in content before validating it. So if you know you are parsing a `JSON.stringify`-ed string, pass `JSON` as the 3rd arg to `zparse`
+When calling `zparse`, if the unknownContent was not a string, or if no format is specified, or if the specified format is not supported, `zparse` will not modify the passed in content before validating it. So if you know you are parsing a `JSON.stringify`-ed string, pass `JSON` as the 3rd arg to `zparse`.
 
 When calling `zstringify`, if no format is specified, or if the specified format is not supported, `zparse` fall back to assuming the format was `JSON`.
 

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as neverthrow0$1 from "neverthrow";
-import * as neverthrow4 from "neverthrow";
 import * as neverthrow0 from "neverthrow";
+import * as neverthrow1 from "neverthrow";
 import { ResultAsync } from "neverthrow";
 import { ParseOptions as ParseOptions$1 } from "jsonc-parser";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -21,6 +21,7 @@ declare class EnhancedError<T = unknown> extends Error {
 declare class ParseError extends EnhancedError {}
 type ParseOptions = {
   json: ParseJSONOptions;
+  format?: string;
 };
 declare const defaultParseOptions: {
   readonly json: {
@@ -29,9 +30,14 @@ declare const defaultParseOptions: {
     readonly disallowComments: true;
   };
 };
-declare const parseIt: (stringifiedContent: string, formatAndParseOptions: Partial<ParseOptions & {
-  format: string;
-}>) => neverthrow0$1.Result<unknown, ParseError>;
+declare const parseIt: (stringifiedContent: string, parseOptions: ParseOptions) => neverthrow0$1.Result<unknown, ParseError>;
+//#endregion
+//#region src/schema.d.ts
+interface StringSchema extends StandardSchemaV1<string> {
+  type: "string";
+  message: string;
+}
+declare function parseString(message?: string): StringSchema;
 //#endregion
 //#region src/stringify.d.ts
 declare class StringifyError extends EnhancedError {}
@@ -43,7 +49,7 @@ declare const defaultStringifyOptions: {
 };
 declare const stringifyIt: (unknownContent: unknown, formatAndStringifyOptions: Partial<StringifyOptions & {
   format: string;
-}>) => neverthrow4.Result<string, StringifyError>;
+}>) => neverthrow0.Result<string, StringifyError>;
 //#endregion
 //#region src/typeHelpers.d.ts
 type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
@@ -56,7 +62,7 @@ declare class ValidationError extends EnhancedError {
   readonly issues: ReadonlyArray<StandardSchemaV1.Issue>;
   constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
 }
-declare const validateIt: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema) => ResultAsync<unknown, ValidationError>;
+declare const validateIt: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema) => ResultAsync<StandardSchemaV1.InferOutput<Schema>, ValidationError>;
 //#endregion
 //#region src/zerde.d.ts
 type ZerdeOptions = Partial<{
@@ -75,11 +81,11 @@ declare class Zerde {
     readonly json: 0;
   };
   constructor(options?: ZerdeOptions);
-  parse: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<ParseOptions>) => neverthrow0.ResultAsync<unknown, ParseError | ValidationError>;
-  stringify: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | Partial<StringifyOptions>) => neverthrow0.ResultAsync<string, ValidationError | StringifyError>;
+  parse: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<ParseOptions>) => neverthrow1.ResultAsync<StandardSchemaV1.InferOutput<Schema>, ParseError | ValidationError>;
+  stringify: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | Partial<StringifyOptions>) => neverthrow1.ResultAsync<string, StringifyError | ValidationError>;
 }
 declare const zerde: Zerde;
-declare const zparse: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<ParseOptions>) => neverthrow0.ResultAsync<unknown, ParseError | ValidationError>;
-declare const zstringify: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | Partial<StringifyOptions>) => neverthrow0.ResultAsync<string, ValidationError | StringifyError>;
+declare const zparse: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<ParseOptions>) => neverthrow1.ResultAsync<StandardSchemaV1.InferOutput<Schema>, ParseError | ValidationError>;
+declare const zstringify: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | Partial<StringifyOptions>) => neverthrow1.ResultAsync<string, StringifyError | ValidationError>;
 //#endregion
-export { EnhancedError, type ErrorInfo, ParseError, type ParseOptions, Prettify, StringifyError, type StringifyOptions, ValidationError, Zerde, type ZerdeOptions, defaultParseOptions, defaultStringifyOptions, objectEntries, objectKeys, parseIt, stringifyIt, validateIt, zerde, zparse, zstringify };
+export { EnhancedError, type ErrorInfo, ParseError, type ParseOptions, Prettify, type StringSchema, StringifyError, type StringifyOptions, ValidationError, Zerde, type ZerdeOptions, defaultParseOptions, defaultStringifyOptions, objectEntries, objectKeys, parseIt, parseString, stringifyIt, validateIt, zerde, zparse, zstringify };

package/dist/index.js

@@ -1 +1 @@
-import{ResultAsync as e,fromThrowable as t}from"neverthrow";import{parse as n}from"jsonc-parser";import{configure as r}from"safe-stable-stringify";const i={allowEmptyContent:!0,allowTrailingComma:!0,disallowComments:!0};function a(e,t={}){let r={...t,...i},a=[],o=n(e,a,r);if(a.length>0)throw SyntaxError(`Could not parse JSON`,{cause:a});return o}const o=0,s=r({bigint:!1,circularValue:SyntaxError,deterministic:!0,strict:!0});function c(e,t){let n=s(e,null,t);if(n===void 0)throw SyntaxError(`safe-stable-stringify should have thrown an error if trying to stringify an invalid json object`);return n}const l=Object.keys,u=Object.entries;var d=class extends Error{constructor(e,t){super(e,{cause:t.cause}),this.name=this.constructor.name}};const f=[`.`,`/`,`\\`,`+`];function p(e){let t=e.trim().toLowerCase();if(!t)return t;let n=t.indexOf(`;`);n>0&&(t=t.slice(0,n));let r=Math.max(...f.map(e=>t.lastIndexOf(e)));return r<0?t:t.slice(r+1)}if(import.meta.vitest){let{describe:e,it:t,expect:n}=import.meta.vitest,r={lowercase:`json`,uppercase:`JSON`,mixedcase:`jSoN`,extension:`.json`,file:`file.json`,"file with path":`some/path/to/file.json`,"file with a windows path":`some\\path\\to\\file.json`,"basic media type":`application/json`,"complex media type":`application/customFormat+json`,"media type with charset":`application/customFormat+json; charset=utf-8`};e(`extractFormatSuffix`,()=>{for(let[e,i]of u(r)){let r=`Can handle ${e}: ${i}`;t(r,()=>{n(p(i)).toEqual(`json`)})}})}var m=class extends d{};const h={json:i},g=t((e,t)=>{let{format:n,...r}=t,i=p(n??``);return i===`json`?a(e,r.json):e},e=>new m(`Could not parse content`,{cause:e}));var _=class extends d{};const v={json:o},y=t((e,t)=>{if(typeof e==`string`)return e;let{format:n,...r}=t,i=p(n??``);return c(e,r.json)},e=>new _(`Could not stringify content`,{cause:e}));var b=class extends d{issues;constructor(e){super(`Content was not valid`,{cause:e}),this.issues=e}};const x=e.fromThrowable(async(e,t)=>{let n=await t[`~standard`].validate(e);if(n.issues)throw new b(n.issues);return n.value},e=>e);var S=class{parseOptions=h;stringifyOptions=v;constructor(e={}){this.parseOptions={...e.parse,...h}}parse=(e,t,n)=>{if(typeof e==`string`){let r=typeof n==`string`?{format:n}:n,i={...this.parseOptions,...r};return g(e,i).asyncAndThen(e=>x(e,t))}return x(e,t)};stringify=(e,t,n)=>{let r=typeof n==`string`?{format:n}:n,i={...this.stringifyOptions,...r};return x(e,t).andThen(e=>y(e,i))}};const C=new S,w=C.parse,T=C.stringify;export{d as EnhancedError,m as ParseError,_ as StringifyError,b as ValidationError,S as Zerde,h as defaultParseOptions,v as defaultStringifyOptions,u as objectEntries,l as objectKeys,g as parseIt,y as stringifyIt,x as validateIt,C as zerde,w as zparse,T as zstringify};
+import{ResultAsync as e,fromThrowable as t}from"neverthrow";import{parse as n}from"jsonc-parser";import{configure as r}from"safe-stable-stringify";const i={allowEmptyContent:!0,allowTrailingComma:!0,disallowComments:!0};function a(e,t={}){let r={...t,...i},a=[],o=n(e,a,r);if(a.length>0)throw SyntaxError(`Could not parse JSON`,{cause:a});return o}const o=0,s=r({bigint:!1,circularValue:SyntaxError,deterministic:!0,strict:!0});function c(e,t){let n=s(e,null,t);if(n===void 0)throw SyntaxError(`safe-stable-stringify should have thrown an error if trying to stringify an invalid json object`);return n}const l=Object.keys,u=Object.entries;var d=class extends Error{constructor(e,t){super(e,{cause:t.cause}),this.name=this.constructor.name}};const f=[`.`,`/`,`\\`,`+`];function p(e){let t=e.trim().toLowerCase();if(!t)return t;let n=t.indexOf(`;`);n>0&&(t=t.slice(0,n));let r=Math.max(...f.map(e=>t.lastIndexOf(e)));return r<0?t:t.slice(r+1)}if(import.meta.vitest){let{describe:e,it:t,expect:n}=import.meta.vitest,r={lowercase:`json`,uppercase:`JSON`,mixedcase:`jSoN`,extension:`.json`,file:`file.json`,"file with path":`some/path/to/file.json`,"file with a windows path":`some\\path\\to\\file.json`,"basic media type":`application/json`,"complex media type":`application/customFormat+json`,"media type with charset":`application/customFormat+json; charset=utf-8`};e(`extractFormatSuffix`,()=>{for(let[e,i]of u(r)){let r=`Can handle ${e}: ${i}`;t(r,()=>{n(p(i)).toEqual(`json`)})}})}var m=class extends d{};const h={json:i},g=t((e,t)=>{let{format:n,...r}=t,i=l(r).sort().at(0)??``,o=p(n??i);return o===`json`?a(e,r.json):e},e=>new m(`Could not parse content`,{cause:e}));function _(e=`Invalid type`){return{type:`string`,message:e,"~standard":{version:1,vendor:`StandardSchema`,validate(t){return typeof t==`string`?{value:t}:{issues:[{message:e}]}}}}}var v=class extends d{};const y={json:o},b=t((e,t)=>{if(typeof e==`string`)return e;let{format:n,...r}=t,i=p(n??``);return c(e,r.json)},e=>new v(`Could not stringify content`,{cause:e}));var x=class extends d{issues;constructor(e){super(`Content was not valid`,{cause:e}),this.issues=e}};const S=e.fromThrowable(async(e,t)=>{let n=await t[`~standard`].validate(e);if(n.issues)throw new x(n.issues);return n.value},e=>e);var C=class{parseOptions=h;stringifyOptions=y;constructor(e={}){this.parseOptions={...e.parse,...h}}parse=(e,t,n)=>{if(typeof e==`string`){let r=typeof n==`string`?{format:n}:n,i={...this.parseOptions,...r};return g(e,i).asyncAndThen(e=>S(e,t))}return S(e,t)};stringify=(e,t,n)=>{let r=typeof n==`string`?{format:n}:n,i={...this.stringifyOptions,...r};return S(e,t).andThen(e=>b(e,i))}};const w=new C,T=w.parse,E=w.stringify;export{d as EnhancedError,m as ParseError,v as StringifyError,x as ValidationError,C as Zerde,h as defaultParseOptions,y as defaultStringifyOptions,u as objectEntries,l as objectKeys,g as parseIt,_ as parseString,b as stringifyIt,S as validateIt,w as zerde,T as zparse,E as zstringify};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zerde",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "description": "parsing, and stringifying combined with schema validation",
     "keywords": [
         "parse",
@@ -9,7 +9,10 @@
         "validation",
         "schema"
     ],
-    "repository": "github:dannywexler/zerde",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dannywexler/zerde.git"
+    },
     "author": "Danny Wexler",
     "license": "MIT",
     "type": "module",
@@ -38,8 +41,6 @@
     },
     "scripts": {
         "build": "lefthook run build",
-        "lint": "biome check --error-on-warnings --colors=force --write src",
-        "test": "vitest run",
         "test:watch": "vitest"
     },
     "dependencies": {