zerde 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -1,13 +1,28 @@
-import * as neverthrow0$1 from "neverthrow";
+import { ParseOptions as ParseOptions$1 } from "jsonc-parser";
+import { CreateNodeOptions, DocumentOptions, ParseOptions as ParseOptions$2, SchemaOptions, ToJSOptions, ToStringOptions } from "yaml";
+import * as neverthrow4 from "neverthrow";
+import * as neverthrow3 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";
+import { StandardSchemaV1, StandardSchemaV1 as StandardSchemaV1$1 } from "@standard-schema/spec";
 
 //#region src/formats/json.d.ts
 type ParseJSONOptions = Partial<ParseOptions$1>;
+declare const defaultParseJSONOptions: {
+  allowEmptyContent: false;
+  allowTrailingComma: false;
+  disallowComments: true;
+};
+declare function parseJSON(stringifiedContent: string, parseOptions?: ParseJSONOptions): unknown;
 type StringifyJSONOptions = string | number;
+declare const defaultStringifyJSONOptions: 0;
+declare function stringifyJSON(unknownContent: unknown, stringifyOptions?: StringifyJSONOptions): string;
+//#endregion
+//#region src/formats/yaml.d.ts
+type ParseYAMLOptions = DocumentOptions & ParseOptions$2 & SchemaOptions & ToJSOptions;
+declare function parseYAML(stringifiedContent: string, parseOptions?: ParseYAMLOptions): unknown;
+type StringifyYAMLOptions = CreateNodeOptions & DocumentOptions & ParseOptions$2 & SchemaOptions & ToStringOptions;
+declare function stringifyYAML(unknownContent: unknown, stringifyOptions?: StringifyYAMLOptions): string;
 //#endregion
 //#region src/utils.d.ts
 type ErrorInfo<T> = T & {
@@ -16,40 +31,58 @@ type ErrorInfo<T> = T & {
 declare class EnhancedError<T = unknown> extends Error {
   constructor(message: string, info: ErrorInfo<T>);
 }
+declare function extractFormatSuffix(format: string): string;
 //#endregion
 //#region src/parse.d.ts
-declare class ParseError extends EnhancedError {}
-type ParseOptions = {
+declare class ParseError extends EnhancedError {
+  readonly tag = "ParseError";
+  constructor(cause: unknown);
+}
+type ParseOptions = Partial<{
   json: ParseJSONOptions;
-  format?: string;
-};
+  yaml: ParseYAMLOptions;
+  format: string;
+}>;
 declare const defaultParseOptions: {
   readonly json: {
-    readonly allowEmptyContent: true;
-    readonly allowTrailingComma: true;
-    readonly disallowComments: true;
+    allowEmptyContent: false;
+    allowTrailingComma: false;
+    disallowComments: true;
   };
+  readonly yaml: {};
 };
-declare const parseIt: (stringifiedContent: string, parseOptions: ParseOptions) => neverthrow0$1.Result<unknown, ParseError>;
+declare const parseIt: (stringifiedContent: string, parseOptions: Partial<{
+  json: ParseJSONOptions;
+  yaml: ParseYAMLOptions;
+  format: string;
+}>) => neverthrow4.Result<unknown, ParseError>;
 //#endregion
 //#region src/schema.d.ts
-interface StringSchema extends StandardSchemaV1<string> {
+interface StringSchema extends StandardSchemaV1$1<string> {
   type: "string";
   message: string;
 }
 declare function parseString(message?: string): StringSchema;
 //#endregion
 //#region src/stringify.d.ts
-declare class StringifyError extends EnhancedError {}
-type StringifyOptions = {
+declare class StringifyError extends EnhancedError {
+  readonly tag = "StringifyError";
+  constructor(cause: unknown);
+}
+type StringifyOptions = Partial<{
   json: StringifyJSONOptions;
-};
+  yaml: StringifyYAMLOptions;
+}>;
 declare const defaultStringifyOptions: {
   readonly json: 0;
+  readonly yaml: {};
 };
-declare const stringifyIt: (unknownContent: unknown, formatAndStringifyOptions: Partial<StringifyOptions & {
+declare const stringifyIt: (unknownContent: unknown, formatAndStringifyOptions: Partial<Partial<{
+  json: StringifyJSONOptions;
+  yaml: StringifyYAMLOptions;
+}> & {
   format: string;
-}>) => neverthrow0.Result<string, StringifyError>;
+}>) => neverthrow3.Result<string, StringifyError>;
 //#endregion
 //#region src/typeHelpers.d.ts
 type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
@@ -58,11 +91,17 @@ 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.Issue>;
-  constructor(issues: ReadonlyArray<StandardSchemaV1.Issue>);
+  readonly tag = "ValidationError";
+  readonly originalValue: unknown;
+  readonly issues: ValidationIssues;
+  constructor(originalValue: unknown, issues: ValidationIssues);
 }
-declare const validateIt: <Schema extends StandardSchemaV1>(unknownContent: unknown, schema: Schema) => ResultAsync<StandardSchemaV1.InferOutput<Schema>, ValidationError>;
+declare const validateIt: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema) => ResultAsync<StandardSchemaV1$1.InferOutput<Schema>, ValidationError>;
 //#endregion
 //#region src/zerde.d.ts
 type ZerdeOptions = Partial<{
@@ -70,22 +109,21 @@ type ZerdeOptions = Partial<{
   stringify: StringifyOptions;
 }>;
 declare class Zerde {
-  parseOptions: {
-    readonly json: {
-      readonly allowEmptyContent: true;
-      readonly allowTrailingComma: true;
-      readonly disallowComments: true;
-    };
-  };
-  stringifyOptions: {
-    readonly json: 0;
-  };
+  parseOptions: ParseOptions;
+  stringifyOptions: StringifyOptions;
   constructor(options?: ZerdeOptions);
-  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>;
+  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>(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>;
+declare const zparse: <Schema extends StandardSchemaV1$1>(unknownContent: unknown, schema: Schema, parseOptions?: string | Partial<{
+  json: ParseJSONOptions;
+  yaml: ParseYAMLOptions;
+  format: string;
+}> | 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) => neverthrow0.ResultAsync<string, ValidationError | StringifyError>;
 //#endregion
-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 };
+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{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:TypeError,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};
+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={...o,...n},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{tag=`ParseError`;constructor(e){super(`Could not parse content`,{cause:e}),this.name=`ParseError`}};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(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{tag=`StringifyError`;constructor(e){super(`Could not stringify content`,{cause:e}),this.name=`StringifyError`}};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(e));var T=class extends h{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 E=i.fromThrowable(async(e,t)=>{let n=await t[`~standard`].validate(e);if(n.issues){let t=n.issues.map(t=>({...t,input:D(e,t)}));throw new T(e,t)}return n.value},e=>e);function D(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(D(a,r)).toEqual(o)})}})}var O=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 k=new O,A=k.parse,j=k.stringify;export{h as EnhancedError,v as ParseError,S as StringifyError,T as ValidationError,O 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,k as zerde,A as zparse,j as zstringify};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "zerde",
-    "version": "0.1.3",
+    "version": "0.1.5",
     "description": "parsing, and stringifying combined with schema validation",
     "keywords": [
         "parse",
@@ -47,6 +47,7 @@
         "@standard-schema/spec": "^1.0.0",
         "jsonc-parser": "^3.3.1",
         "neverthrow": "^8.2.0",
-        "safe-stable-stringify": "^2.5.0"
+        "safe-stable-stringify": "^2.5.0",
+        "yaml": "^2.8.2"
     }
 }