zerde 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { ParseOptions as ParseOptions$1 } from "jsonc-parser";
 import { CreateNodeOptions, DocumentOptions, ParseOptions as ParseOptions$2, SchemaOptions, ToJSOptions, ToStringOptions } from "yaml";
-import * as neverthrow0$1 from "neverthrow";
+import * as neverthrow3 from "neverthrow";
+import * as neverthrow4 from "neverthrow";
 import * as neverthrow0 from "neverthrow";
-import * as neverthrow1 from "neverthrow";
 import { ResultAsync } from "neverthrow";
 import { StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
 
@@ -34,7 +34,10 @@ declare class EnhancedError<T = unknown> extends Error {
 declare function extractFormatSuffix(format: string): string;
 //#endregion
 //#region src/parse.d.ts
-declare class ParseError extends EnhancedError {}
+declare class ParseError extends EnhancedError {
+  readonly tag = "ParseError";
+  constructor(cause: unknown);
+}
 type ParseOptions = Partial<{
   json: ParseJSONOptions;
   yaml: ParseYAMLOptions;
@@ -52,7 +55,7 @@ declare const parseIt: (stringifiedContent: string, parseOptions: Partial<{
   json: ParseJSONOptions;
   yaml: ParseYAMLOptions;
   format: string;
-}>) => neverthrow0$1.Result<unknown, ParseError>;
+}>) => neverthrow3.Result<unknown, ParseError>;
 //#endregion
 //#region src/schema.d.ts
 interface StringSchema extends StandardSchemaV1$1<string> {
@@ -62,7 +65,10 @@ interface StringSchema extends StandardSchemaV1$1<string> {
 declare function parseString(message?: string): StringSchema;
 //#endregion
 //#region src/stringify.d.ts
-declare class StringifyError extends EnhancedError {}
+declare class StringifyError extends EnhancedError {
+  readonly tag = "StringifyError";
+  constructor(cause: unknown);
+}
 type StringifyOptions = Partial<{
   json: StringifyJSONOptions;
   yaml: StringifyYAMLOptions;
@@ -76,7 +82,7 @@ declare const stringifyIt: (unknownContent: unknown, formatAndStringifyOptions:
   yaml: StringifyYAMLOptions;
 }> & {
   format: string;
-}>) => neverthrow0.Result<string, StringifyError>;
+}>) => neverthrow4.Result<string, StringifyError>;
 //#endregion
 //#region src/typeHelpers.d.ts
 type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
@@ -85,9 +91,15 @@ declare const objectEntries: <Type extends Record<string, unknown>>(value: Type)
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
 //#endregion
 //#region src/validate.d.ts
+interface ValidationIssue extends StandardSchemaV1$1.Issue {
+  input: unknown;
+}
+type ValidationIssues = ReadonlyArray<ValidationIssue>;
 declare class ValidationError extends EnhancedError {
-  readonly issues: ReadonlyArray<StandardSchemaV1$1.Issue>;
-  constructor(issues: ReadonlyArray<StandardSchemaV1$1.Issue>);
+  readonly tag = "ValidationError";
+  readonly originalValue: unknown;
+  readonly issues: ValidationIssues;
+  constructor(originalValue: unknown, issues: ValidationIssues);
 }
 declare const validateIt: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema) => ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ValidationError>;
 //#endregion
@@ -100,18 +112,18 @@ declare class Zerde {
   parseOptions: ParseOptions;
   stringifyOptions: StringifyOptions;
   constructor(options?: ZerdeOptions);
-  parse: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, parseOptions?: string | ParseOptions) => neverthrow1.ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ParseError | ValidationError>;
-  stringify: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | StringifyOptions) => neverthrow1.ResultAsync<string, StringifyError | ValidationError>;
+  parse: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, parseOptions?: string | ParseOptions) => neverthrow0.ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ParseError | ValidationError>;
+  stringify: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | StringifyOptions) => neverthrow0.ResultAsync<string, ValidationError | StringifyError>;
 }
 declare const zerde: Zerde;
 declare const zparse: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<{
   json: ParseJSONOptions;
   yaml: ParseYAMLOptions;
   format: string;
-}> | undefined) => neverthrow1.ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ParseError | ValidationError>;
+}> | undefined) => neverthrow0.ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ParseError | ValidationError>;
 declare const zstringify: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, stringifyOptions?: string | Partial<{
   json: StringifyJSONOptions;
   yaml: StringifyYAMLOptions;
-}> | undefined) => neverthrow1.ResultAsync<string, StringifyError | ValidationError>;
+}> | undefined) => neverthrow0.ResultAsync<string, ValidationError | StringifyError>;
 //#endregion
-export { EnhancedError, ErrorInfo, ParseError, ParseJSONOptions, ParseOptions, ParseYAMLOptions, Prettify, type StandardSchemaV1, StringSchema, StringifyError, StringifyJSONOptions, StringifyOptions, StringifyYAMLOptions, ValidationError, Zerde, ZerdeOptions, defaultParseJSONOptions, defaultParseOptions, defaultStringifyJSONOptions, defaultStringifyOptions, extractFormatSuffix, objectEntries, objectKeys, parseIt, parseJSON, parseString, parseYAML, stringifyIt, stringifyJSON, stringifyYAML, validateIt, zerde, zparse, zstringify };
+export { EnhancedError, ErrorInfo, ParseError, ParseJSONOptions, ParseOptions, ParseYAMLOptions, Prettify, type StandardSchemaV1, StringSchema, StringifyError, StringifyJSONOptions, StringifyOptions, StringifyYAMLOptions, ValidationError, ValidationIssue, ValidationIssues, Zerde, ZerdeOptions, defaultParseJSONOptions, defaultParseOptions, defaultStringifyJSONOptions, defaultStringifyOptions, extractFormatSuffix, objectEntries, objectKeys, parseIt, parseJSON, parseString, parseYAML, stringifyIt, stringifyJSON, stringifyYAML, validateIt, zerde, zparse, zstringify };

package/dist/index.js

@@ -1 +1 @@
-import{parse as e}from"jsonc-parser";import{configure as t}from"safe-stable-stringify";import{parse as n,stringify as r}from"yaml";import{ResultAsync as i,fromThrowable as a}from"neverthrow";const o={allowEmptyContent:!1,allowTrailingComma:!1,disallowComments:!0};function s(t,n={}){let r={...n,...o},i=[],a=e(t,i,r);if(i.length>0)throw SyntaxError(`Could not parse JSON`,{cause:i});return a}const c=0,l=t({bigint:!1,circularValue:TypeError,deterministic:!0,strict:!0});function u(e,t){let n=l(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}function d(e,t={}){return n(e,t)}function f(e,t={}){return r(e,{sortMapEntries:!0,...t})}const p=Object.keys,m=Object.entries;var h=class extends Error{constructor(e,t){super(e,{cause:t.cause}),this.name=this.constructor.name}};const g=[`.`,`/`,`\\`,`+`];function _(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(...g.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 m(r)){let r=`Can handle ${e}: ${i}`;t(r,()=>{n(_(i)).toEqual(`json`)})}})}var v=class extends h{};const y={json:o,yaml:{}},b=a((e,t)=>{let{format:n,...r}=t,i=p(r).sort().at(0)??``,a=_(n??i);return a===`yaml`||a===`yml`?d(e,r.yaml):a===`json`?s(e,r.json):e},e=>new v(`Could not parse content`,{cause:e}));function x(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 S=class extends h{};const C={json:c,yaml:{}},w=a((e,t)=>{if(typeof e==`string`)return e;let{format:n,...r}=t,i=_(n??``);return i===`yaml`||i===`yml`?f(e,r.yaml):u(e,r.json)},e=>new S(`Could not stringify content`,{cause:e}));var T=class extends h{issues;constructor(e){super(`Content was not valid`,{cause:e}),this.issues=e}};const E=i.fromThrowable(async(e,t)=>{let n=await t[`~standard`].validate(e);if(n.issues)throw new T(n.issues);return n.value},e=>e);var D=class{parseOptions;stringifyOptions;constructor(e={}){this.parseOptions={...y,...e.parse},this.stringifyOptions={...C,...e.stringify}}parse=(e,t,n)=>{if(typeof e==`string`){let r=typeof n==`string`?{format:n}:n,i={...this.parseOptions,...r};return b(e,i).asyncAndThen(e=>E(e,t))}return E(e,t)};stringify=(e,t,n)=>{let r=typeof n==`string`?{format:n}:n,i={...this.stringifyOptions,...r};return E(e,t).andThen(e=>w(e,i))}};const O=new D,k=O.parse,A=O.stringify;export{h as EnhancedError,v as ParseError,S as StringifyError,T as ValidationError,D as Zerde,o as defaultParseJSONOptions,y as defaultParseOptions,c as defaultStringifyJSONOptions,C as defaultStringifyOptions,_ as extractFormatSuffix,m as objectEntries,p as objectKeys,b as parseIt,s as parseJSON,x as parseString,d as parseYAML,w as stringifyIt,u as stringifyJSON,f as stringifyYAML,E as validateIt,O as zerde,k as zparse,A as zstringify};
+import{parse as e}from"jsonc-parser";import{configure as t}from"safe-stable-stringify";import{serializeError as n}from"serialize-error";import{parse as r,stringify as i}from"yaml";import{ResultAsync as a,fromThrowable as o}from"neverthrow";const s={allowEmptyContent:!1,allowTrailingComma:!1,disallowComments:!0};function c(t,n){try{return JSON.parse(t)}catch{let r={...s,...n},i=[],a=e(t,i,r);if(i.length>0)throw SyntaxError(`Could not parse JSON`,{cause:i});return a}}const l=0,u=t({bigint:!1,circularValue:TypeError,deterministic:!0,strict:!0});function d(e,t){let r=Error.isError(e)?n(e):e,i=u(r,null,t);if(i===void 0)throw SyntaxError(`safe-stable-stringify should have thrown an error if trying to stringify an invalid json object`);return i}function f(e,t){return r(e,t)}function p(e,t){return i(e,{sortMapEntries:!0,...t})}const m=Object.keys,h=Object.entries;var g=class extends Error{constructor(e,t){super(e,{cause:t.cause}),this.name=this.constructor.name}};const _=[`.`,`/`,`\\`,`+`];function v(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(..._.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 h(r)){let r=`Can handle ${e}: ${i}`;t(r,()=>{n(v(i)).toEqual(`json`)})}})}var y=class extends g{tag=`ParseError`;constructor(e){super(`Could not parse content`,{cause:e}),this.name=`ParseError`}};const b={json:s,yaml:{}},x=o((e,t)=>{let{format:n,...r}=t,i=m(r).sort().at(0)??``,a=v(n??i);return a===`yaml`||a===`yml`?f(e,r.yaml):a===`json`?c(e,r.json):e},e=>new y(e));function S(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 C=class extends g{tag=`StringifyError`;constructor(e){super(`Could not stringify content`,{cause:e}),this.name=`StringifyError`}};const w={json:l,yaml:{}},T=o((e,t)=>{if(typeof e==`string`)return e;let{format:n,...r}=t,i=v(n??``);return i===`yaml`||i===`yml`?p(e,r.yaml):d(e,r.json)},e=>new C(e));var E=class extends g{tag=`ValidationError`;originalValue;issues;constructor(e,t){super(`Content was not valid`,{cause:void 0}),this.originalValue=e,this.issues=t,this.name=`ValidationError`}};const D=a.fromThrowable(async(e,t)=>{let n=await t[`~standard`].validate(e);if(n.issues){let t=n.issues.map(t=>({...t,input:O(e,t)}));throw new E(e,t)}return n.value},e=>e);function O(e,t){let n=e;for(let e of t.path??[])n=n[e];return n}if(import.meta.vitest){let{describe:e,it:t,expect:n}=import.meta.vitest,r=[[`simpleObject`,[`hello`],{hello:`world`},`world`],[`nestedObject`,[`deeply`,`nested`,`object`],{deeply:{nested:{object:`someValue`}}},`someValue`],[`array`,[1],[`zero`,`one`],`one`],[`noPath`,void 0,{hello:`world`},{hello:`world`}]];e(`extractOriginalInput`,()=>{for(let[e,i,a,o]of r){let r={message:`something went wrong`,path:i};t(`Can handle ${e}`,()=>{n(O(a,r)).toEqual(o)})}})}var k=class{parseOptions;stringifyOptions;constructor(e={}){this.parseOptions={...b,...e.parse},this.stringifyOptions={...w,...e.stringify}}parse=(e,t,n)=>{if(typeof e==`string`){let r=typeof n==`string`?{format:n}:n,i={...this.parseOptions,...r};return x(e,i).asyncAndThen(e=>D(e,t))}return D(e,t)};stringify=(e,t,n)=>{let r=typeof n==`string`?{format:n}:n,i={...this.stringifyOptions,...r};return D(e,t).andThen(e=>T(e,i))}};const A=new k,j=A.parse,M=A.stringify;export{g as EnhancedError,y as ParseError,C as StringifyError,E as ValidationError,k as Zerde,s as defaultParseJSONOptions,b as defaultParseOptions,l as defaultStringifyJSONOptions,w as defaultStringifyOptions,v as extractFormatSuffix,h as objectEntries,m as objectKeys,x as parseIt,c as parseJSON,S as parseString,f as parseYAML,T as stringifyIt,d as stringifyJSON,p as stringifyYAML,D as validateIt,A as zerde,j as zparse,M as zstringify};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zerde",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "parsing, and stringifying combined with schema validation",
     "keywords": [
         "parse",
@@ -44,10 +44,11 @@
         "test:watch": "vitest"
     },
     "dependencies": {
-        "@standard-schema/spec": "^1.0.0",
+        "@standard-schema/spec": "^1.1.0",
         "jsonc-parser": "^3.3.1",
         "neverthrow": "^8.2.0",
         "safe-stable-stringify": "^2.5.0",
-        "yaml": "^2.8.2"
+        "serialize-error": "^13.0.1",
+        "yaml": "^2.8.3"
     }
 }