jasone 0.0.4 → 1.0.0-beta.0

package/README.md

@@ -1,12 +1,13 @@
 # Jasone
 
-A lightweight, extensible JSON encoder and decoder which supports custom types.
+A lightweight, extensible JSON encoder and decoder that supports custom types.
 
-**NOTICE:** Jasone is still in early development and might not be stable yet.
+**NOTICE:** The documentation is still in progress and a lot of things are missing.
 
 ## Features
 
 - 🚀 Fast & Lightweight: Minimal footprint.
+- 🧩 Zero dependencies: No external packages required.
 - 🔌 Extensible: Easily add custom types.
 - 💻 TypeScript: Written in TypeScript for type safety and better DX.
 
@@ -33,87 +34,77 @@ bun add jasone
 ```ts
 import { Jasone } from "jasone";
 
-const data = { myDate: new Date("2025-04-05T14:30:00.000+02:00") };
+const data = { myDate: new Date("2025-04-05T14:30:00.000Z") };
 const encoded = JSON.stringify(Jasone.encode(data));
 
-console.log(encoded); // {"myDate":{"$":1,"timestamp":1743856200000}}
+console.log(encoded); // {"myDate":{"$":1,"iso":"2025-04-05T12:30:00.000Z"}}
 ```
 
 ### Decoding
 
 ```ts
-import { decode } from "jasone";
+import { Jasone } from "jasone";
 
-const encoded = '{"myDate":{"$":1,"timestamp":1743856200000}}';
+const encoded = '{"myDate":{"$":1,"iso":"2025-04-05T12:30:00.000Z"}}';
 const decoded = Jasone.decode(JSON.parse(encoded));
 
-console.log(decoded); // { myDate: new Date("2025-04-05T14:30:00.000+02:00") }
+console.log(decoded); // { myDate: new Date("2025-04-05T12:30:00.000Z") }
 ```
 
 ## Advanced Usage
 
-Adding custom types is really easy. You just need to create an transformer object and register it with Jasone.
+Adding custom types is easy. You just need to create a transformer object and register it with Jasone.
 
 ```ts
-import { Jasone } from "jasone";
+import { defaultTransformers, Jasone, type Transformer } from "jasone";
 
 class Car {
-  constructor(public brand: string, public model: string) {}
+  constructor(
+    public brand: string,
+    public model: string,
+  ) {}
 
   // ...
 }
 
-// use the `createType` helper
-const myType = createType({
-  // the match function is used to determine if the transformer can encode the given value
-  matches: (value) => value instanceof Car,
-
-  // the type id is used to identify the type on the encoded object
-  // (this needs to be unique and a string, numbers are currently reserved for built-in types)
-  typeId: "Car"
-
-  // the encode function which receives the matched value and need to return an valid JSON object
-  encode: (car) => ({ brand: car.brand, model: car.model }),
-
-  // the decode function which receives the encoded JSON object and needs to return a original value
-  decode: ({brand, model}) => new Car(brand, model),
-});
-```
-
-For classes, you can also use a bit more performant way of creating the transformer object:
-
-```ts
-const myType = createType({
-  // by using the `target` property, under the hood, Jasone will use the constructor to match
-  // the type. Which is more performant than using the `matches` property.
-  target: Car,
-  typeId: "Car",
-  encode: (car) => ({brand: car.brand, model: car.model}),
-  decode: ({brand, model}) => new Car(brand, model),
-});
-```
-
-Now the only thing left is to register the type with Jasone:
-
-```ts
-Jasone.register(myType);
+const carType: Transformer<Car, { brand: string; model: string }> = {
+  encoder: {
+    // The filter is used to determine if the transformer can encode the given value.
+    // There are many different filters, but for classes, the class constructor is the most efficient.
+    filter: { class: Car },
+    // The handler is used to encode the value.
+    handler: ({ value }) => [
+      // The type Id is used to identify the type in the encoded object.
+      "Car",
+      // Any JSON-compatible value needed to reconstruct the original value.
+      { brand: value.brand, model: value.model },
+    ],
+  },
+  decoder: {
+    // The filter is used to determine if the transformer can decode the given value.
+    filter: "Car",
+    // The handler is used to decode the value.
+    handler: ({ value }) => new Car(value.brand, value.model),
+  },
+};
+
+// Register the type with an already instantiated Jasone instance
+Jasone.register(carType);
+
+// Or create a new Jasone instance with the type already registered
+new Jasone({ types: [carType] });
+
+// Or register the type with default built-in transformers like Date, BigInt, Map, etc.
+new Jasone({ types: [carType, ...defaultTransformers] });
 ```
 
-And that's it! If you want multiple instances of Jasone with different types, simply create a new instance like so:
+## Comparison with Superjson
 
-```ts
-const jasone = new Jasone({
-  types: [myType],
-});
-```
-
-Or
+Jasone provides fewer features than Superjson, but is more performant, has a smaller footprint, and uses a simpler JSON format.
 
-```ts
-const jasone = new Jasone();
+If you only need to encode and decode custom types, Jasone is a great choice.
 
-jasone.register(myType);
-```
+If you need features like referential equality, Superjson may be a better choice. However, most of the time, you don't need those features.
 
 ## Contributing
 

package/index.d.ts

@@ -1,143 +1,80 @@
+//#region src/types.d.ts
 /**
  * A JSON-compatible value.
  */
 type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
+  [key: string]: JsonValue;
 };
 /**
  * The id of an encoded type to identify it on decoding.
  */
 type TypeId = string | number;
-/**
- * A function that is responsible to encode a type into a JSON-compatible value.
- *
- * @param value The value to encode.
- * @param encode A function that works exactly the same as `Jasone.encode` useful
- *               to encode values recursively. This function comes from the instance
- *               where the type transformer is registered, so it has the same types.
- * @returns A JSON-compatible value.
- */
-type TypeEncoder<TType = unknown, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = (value: TType, encode: <T = unknown>(value: T) => JsonValue) => TJson;
-/**
- * A function that is responsible to decode a type back to its decoded value.
- *
- * @param value The value to decode.
- * @param encode A function that works exactly the same as `Jasone.decode` useful
- *               to decode values recursively. This function comes from the instance
- *               where the type transformer is registered, so it has the same types.
- * @returns A JSON-compatible value.
- */
-type TypeDecoder<TType = unknown, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = (value: TJson, decode: <T = unknown>(value: JsonValue) => T) => TType;
-type MatchesFn<TType = unknown> = (value: unknown) => value is TType;
-type ClassLike<TInstance> = new <T>(...args: any[]) => TInstance;
-declare const typeOf: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-type TypeOf = typeof typeOf;
-
-type TypeMatcher<TType> = {
-    /**
-     * The function that is responsible to determine if a value can be
-     * encoded with this transformer.
-     */
-    matches: MatchesFn<TType>;
-} | {
-    /**
-     * The class that can be encoded with this transformer.
-     *
-     * Using the `target` property only works on classes with an
-     * `constructor`. Internally, Jasone matches the constructor of the
-     * class with the `target` property.
-     */
-    target: ClassLike<TType>;
+type ClassLike<TInstance> = new (...args: any[]) => TInstance;
+declare const nonJsonTypes: ("bigint" | "symbol" | "undefined" | "object" | "function")[];
+type NonJsonType = {
+  bigint: bigint;
+  function: Function;
+  object: object;
+  symbol: symbol;
+  undefined: undefined;
 };
-/**
- * A type transformer which is responsible for encoding and decoding a type.
- */
-type TypeTransformer<TType, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = TypeMatcher<TType> & {
-    /**
-     * The id of the type that is used to identify the type on decoding.
-     *
-     * This id should be unique for each type and it is recommended to use strings
-     * to avoid conflicts with built-in types (which used positive integers).
-     */
-    typeId: string | number;
-    /**
-     * The function that is responsible to encode the type into a JSON-compatible
-     * value.
-     */
-    encode: TypeEncoder<TType, TJson>;
-    /**
-     * The function that is responsible to decode the type from a JSON-compatible
-     * value.
-     */
-    decode: TypeDecoder<TType, TJson>;
+type EncodeFilter<TType> = {
+  class?: ClassLike<TType>;
+  any?: (value: unknown) => boolean;
+} & { [Key in keyof NonJsonType]?: ((value: NonJsonType[Key]) => boolean) | boolean };
+type EncodeHandler<TType, TJson extends JsonValue> = (ctx: EncodeContext<TType>) => EncodeResult<TJson>;
+type EncodeContext<TType> = {
+  value: TType;
+  jasone: Jasone;
 };
-/**
- * A convenience function to create a type transformer which automatically
- * infer the types for you, so you don't have to.
- *
- * @param transformer The transformer to create.
- * @returns The exact same transformer you passed in, but with the types inferred.
- */
-declare const createType: <TType, TJson extends Record<string, JsonValue>>(transformer: TypeTransformer<TType, TJson>) => TypeTransformer<TType, TJson>;
-
-declare const bigIntType: TypeTransformer<bigint, {
-    bigint: string;
-}>;
-
-declare const dateType: TypeTransformer<Date, {
-    timestamp: number;
-}>;
-
-declare const mapType: TypeTransformer<Map<unknown, unknown>, {
-    map: JsonValue[][];
-}>;
-
-declare const regExpType: TypeTransformer<RegExp, {
-    source: string;
-    flags: string;
-}>;
-
-declare const setType: TypeTransformer<Set<unknown>, {
-    set: JsonValue[];
-}>;
-
-declare const undefinedType: TypeTransformer<undefined, {}>;
-
-declare const urlType: TypeTransformer<URL, {
-    url: string;
-}>;
-
-/**
- * The default types that are used by the default Jasone instance.
- */
-declare const defaultTypes: TypeTransformer<any, any>[];
-
+type EncodeResult<TJson extends JsonValue> = TJson extends Record<string, JsonValue> ? [TypeId, TJson] | [null, JsonValue] : [null, JsonValue];
+type Encoder<TType = unknown, TJson extends JsonValue = JsonValue> = {
+  filter?: EncodeFilter<TType> | EncodeFilter<TType>[];
+  handler: EncodeHandler<TType, TJson>;
+};
+type DecodeFilter = TypeId | ((typeId: TypeId, value: Record<string, JsonValue>) => boolean);
+type DecodeContext<TJson extends Record<string, JsonValue>> = {
+  value: TJson;
+  typeId: TypeId;
+  jasone: Jasone;
+};
+type DecodeHandler<TType, TJson extends Record<string, JsonValue>> = (ctx: DecodeContext<TJson>) => TType;
+type Decoder<TType = unknown, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = {
+  filter?: DecodeFilter | DecodeFilter[];
+  handler: DecodeHandler<TType, TJson>;
+};
+type Transformer<TType = unknown, TJson extends JsonValue = JsonValue> = {
+  encoder?: Encoder<TType, TJson>;
+  decoder?: TJson extends Record<string, JsonValue> ? Decoder<TType, TJson> : never;
+};
+//#endregion
+//#region src/jasone.d.ts
 /**
  * Jasone options that can be passed to the Jasone constructor.
  */
 type JasoneOptions = {
-    /**
-     * The type identifier that is used to determine if an object is a typed object.
-     *
-     * @default "$"
-     */
-    typeIdentifier?: string;
-    /**
-     * The types that are used to encode and decode objects.
-     *
-     * If not provided, the default types are used. By providing your own types,
-     * the default types are not used anymore, so be sure to also include them.
-     *
-     * @example
-     * ```ts
-     * // your custom type WITH default types
-     * const jasone = new Jasone({ types: [myCustomType, ...defaultTypes] });
-     *
-     * // your custom type WITHOUT default types
-     * const jasone = new Jasone({ types: [myCustomType] });
-     * ```
-     */
-    types?: TypeTransformer<any, any>[];
+  /**
+   * The type identifier that is used to determine if an object is a typed object.
+   *
+   * @default "$"
+   */
+  typeIdentifier?: string;
+  /**
+   * The type transformers that are used to transform types.
+   *
+   * If not provided, the default transformers are used. By providing your own transformers,
+   * the default transformers are not used anymore, so be sure to also include them if needed.
+   *
+   * @example
+   * ```ts
+   * // your custom transformer WITH default type transformers
+   * const jasone = new Jasone({ types: [myCustomTransformer, ...defaultTransformers] });
+   *
+   * // your custom transformer WITHOUT default type transformers
+   * const jasone = new Jasone({ types: [myCustomTransformer] });
+   * ```
+   */
+  types?: Transformer<any, any>[];
 };
 /**
  * Jasone is a JSON encoder and decoder that can handle custom types.
@@ -156,118 +93,167 @@ type JasoneOptions = {
  *
  * ```ts
  * // use our own types without the default types (Date, BigInt, Map, etc.)
- * const myInstance = new Jasone({ types: [myCustomType] });
+ * const myInstance = new Jasone({
+ *   types: [myCustomTransformer]
+ * });
  *
  * // or use our own types with the default types (recommend)
- * const myInstance = new Jasone({ types: [myCustomType, ...defaultTypes] });
+ * const myInstance = new Jasone({
+ *   types: [myCustomTransformer, ...defaultTransformers],
+ * });
  *
  * const encoded = myInstance.encode(value);
  * const decoded = myInstance.decode(value);
  * ```
  */
 declare class Jasone {
-    #private;
-    constructor(options?: JasoneOptions);
-    /**
-     * Register a new type to this Jasone instance.
-     *
-     * @param type The type to register.
-     */
-    register<TType, TJson extends Record<string, JsonValue>>(type: TypeTransformer<TType, TJson>): void;
-    /**
-     * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
-     *
-     * @param value The value to encode.
-     * @returns A JSON-compatible Jasone encoded value.
-     */
-    encode(value: unknown): JsonValue;
-    /**
-     * Decode an Jasone encoded value to its decoded value.
-     *
-     * @param value The Jasone encoded value to decode.
-     * @returns The decoded value.
-     */
-    decode<T = unknown>(value: JsonValue): T;
-    /**
-     * Alias for `encode`.
-     */
-    serialize(value: unknown): JsonValue;
-    /**
-     * Alias for `decode`.
-     */
-    deserialize<T = unknown>(value: JsonValue): T;
-    /**
-     * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * JSON.stringify(this.encode(value));
-     * ```
-     */
-    stringify(value: unknown): string;
-    /**
-     * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * this.decode(JSON.parse(value));
-     * ```
-     */
-    parse<T = unknown>(value: string): T;
-    /**
-     * The default Jasone instance with the default types already registered.
-     */
-    static default: Jasone;
-    /**
-     * Register a new type to the default Jasone instance.
-     *
-     * @param type The type to register.
-     */
-    static register: <TType, TJson extends Record<string, JsonValue>>(type: TypeTransformer<TType, TJson>) => void;
-    /**
-     * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
-     *
-     * @param value The value to encode.
-     * @returns A JSON-compatible Jasone encoded value.
-     */
-    static encode: (value: unknown) => JsonValue;
-    /**
-     * Alias for `encode`.
-     */
-    static serialize: (value: unknown) => JsonValue;
-    /**
-     * Decode an Jasone encoded value to its decoded value.
-     *
-     * @param value The Jasone encoded value to decode.
-     * @returns The decoded value.
-     */
-    static decode: <T = unknown>(value: JsonValue) => T;
-    /**
-     * Alias for `decode`.
-     */
-    static deserialize: <T = unknown>(value: JsonValue) => T;
-    /**
-     * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * JSON.stringify(Jasone.encode(value));
-     * ```
-     */
-    static stringify: (value: unknown) => string;
-    /**
-     * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * Jasone.decode(JSON.parse(value));
-     * ```
-     */
-    static parse: <T = unknown>(value: string) => T;
+  #private;
+  constructor(options?: JasoneOptions);
+  /**
+   * Register a new type to this Jasone instance.
+   *
+   * @param type The type to register.
+   */
+  register<TType, TJson extends JsonValue>(transformer: Transformer<TType, TJson>): void;
+  /**
+   * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
+   *
+   * @param value The value to encode.
+   * @returns A JSON-compatible Jasone encoded value.
+   */
+  encode(value: unknown): JsonValue;
+  /**
+   * Decode an Jasone encoded value to its decoded value.
+   *
+   * @param value The Jasone encoded value to decode.
+   * @returns The decoded value.
+   */
+  decode<T = unknown>(value: JsonValue): T;
+  /**
+   * Alias for `encode`.
+   */
+  serialize(value: unknown): JsonValue;
+  /**
+   * Alias for `decode`.
+   */
+  deserialize<T = unknown>(value: JsonValue): T;
+  /**
+   * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
+   *
+   * Under the hood, this functions looks like this:
+   *
+   * ```ts
+   * JSON.stringify(this.encode(value));
+   * ```
+   */
+  stringify(value: unknown): string;
+  /**
+   * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
+   *
+   * Under the hood, this functions looks like this:
+   *
+   * ```ts
+   * this.decode(JSON.parse(value));
+   * ```
+   */
+  parse<T = unknown>(value: string): T;
+  /**
+   * The default Jasone instance with the default types already registered.
+   */
+  static default: Jasone;
+  /**
+   * Register a new type to the default Jasone instance.
+   *
+   * @param type The type to register.
+   */
+  /**
+   * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
+   *
+   * @param value The value to encode.
+   * @returns A JSON-compatible Jasone encoded value.
+   */
+  static encode: (value: unknown) => JsonValue;
+  /**
+   * Alias for `encode`.
+   */
+  static serialize: (value: unknown) => JsonValue;
+  /**
+   * Decode an Jasone encoded value to its decoded value.
+   *
+   * @param value The Jasone encoded value to decode.
+   * @returns The decoded value.
+   */
+  static decode: <T = unknown>(value: JsonValue) => T;
+  /**
+   * Alias for `decode`.
+   */
+  static deserialize: <T = unknown>(value: JsonValue) => T;
+  /**
+   * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
+   *
+   * Under the hood, this functions looks like this:
+   *
+   * ```ts
+   * JSON.stringify(Jasone.encode(value));
+   * ```
+   */
+  static stringify: (value: unknown) => string;
+  /**
+   * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
+   *
+   * Under the hood, this functions looks like this:
+   *
+   * ```ts
+   * Jasone.decode(JSON.parse(value));
+   * ```
+   */
+  static parse: <T = unknown>(value: string) => T;
+  /**
+   * Register a new type to this Jasone instance.
+   *
+   * @param type The type to register.
+   */
+  static register: <TType, TJson extends JsonValue>(transformer: Transformer<TType, TJson>) => void;
 }
-
-export { type ClassLike, Jasone, type JasoneOptions, type JsonValue, type MatchesFn, type TypeDecoder, type TypeEncoder, type TypeId, type TypeMatcher, type TypeOf, type TypeTransformer, bigIntType, createType, dateType, defaultTypes, mapType, regExpType, setType, undefinedType, urlType };
+//#endregion
+//#region src/transformers/bigint.d.ts
+declare const bigIntTransformer: Transformer<bigint, {
+  bigint: string;
+}>;
+//#endregion
+//#region src/transformers/date.d.ts
+declare const dateTransformer: Transformer<Date, {
+  iso: string;
+}>;
+//#endregion
+//#region src/transformers/map.d.ts
+declare const mapTransformer: Transformer<Map<unknown, unknown>, {
+  entries: [key: JsonValue, value: JsonValue][];
+}>;
+//#endregion
+//#region src/transformers/regexp.d.ts
+declare const regExpTransformer: Transformer<RegExp, {
+  source: string;
+  flags: string;
+}>;
+//#endregion
+//#region src/transformers/set.d.ts
+declare const setTransformer: Transformer<Set<unknown>, {
+  values: JsonValue[];
+}>;
+//#endregion
+//#region src/transformers/undefined.d.ts
+declare const undefinedTransformer: Transformer<undefined, {}>;
+//#endregion
+//#region src/transformers/url.d.ts
+declare const urlTransformer: Transformer<URL, {
+  url: string;
+}>;
+//#endregion
+//#region src/transformers/index.d.ts
+/**
+ * The default type transformers that are used by the default Jasone instance.
+ */
+declare const defaultTransformers: Transformer[];
+//#endregion
+export { ClassLike, DecodeContext, DecodeFilter, DecodeHandler, Decoder, EncodeContext, EncodeFilter, EncodeHandler, EncodeResult, Encoder, Jasone, JasoneOptions, JsonValue, NonJsonType, Transformer, TypeId, type bigIntTransformer, type dateTransformer, defaultTransformers, type mapTransformer, nonJsonTypes, type regExpTransformer, type setTransformer, type undefinedTransformer, type urlTransformer };

package/index.js

@@ -1 +1 @@
-var o=t=>t;var c=o({matches:t=>typeof t=="bigint",typeId:2,encode:t=>({bigint:t.toString()}),decode:({bigint:t})=>BigInt(t)});var a=o({target:Date,typeId:1,encode:t=>({timestamp:t.getTime()}),decode:({timestamp:t})=>new Date(t)});var y=o({target:Map,typeId:5,encode:(t,e)=>({map:Array.from(t.entries().map(([r,n])=>[e(r),e(n)]))}),decode:({map:t},e)=>new Map(t.map(([r,n])=>{if(r===void 0||n===void 0)throw new Error("Illegal value received.",{cause:t});return[e(r),e(n)]}))});var T=o({target:RegExp,typeId:3,encode:t=>({source:t.source,flags:t.flags}),decode:({source:t,flags:e})=>new RegExp(t,e)});var f=o({target:Set,typeId:4,encode:(t,e)=>({set:Array.from(t.values().map(r=>e(r)))}),decode:({set:t},e)=>new Set(t.map(r=>e(r)))});var m=o({matches:t=>t===void 0,typeId:0,encode:()=>({}),decode:()=>{}});var u=o({target:URL,typeId:6,encode:t=>({url:t.toString()}),decode:({url:t})=>new URL(t)});var h=[m,a,c,T,f,y,u];var i=class t{#e;#r=new Map;#n=new Map;#o=[];constructor(e={}){this.#e=e.typeIdentifier??"$";for(let r of e.types??[])this.register(r)}register(e){this.#r.set(e.typeId,e.decode),"matches"in e?this.#o.push({matches:e.matches,typeId:e.typeId,encode:e.encode}):this.#n.set(e.target,{typeId:e.typeId,encode:e.encode})}encode(e){switch(typeof e){case"string":case"number":case"boolean":return e;case"object":if(e===null)return null;if(Array.isArray(e))return e.map(s=>this.encode(s));if(Object.getPrototypeOf(e)===Object.prototype){let s=Object.fromEntries(Object.entries(e).map(([d,p])=>[d,this.encode(p)]));return this.#e in s&&(s[this.#e]=[this.encode(s[this.#e])]),s}}let r;if(typeof e=="object"&&e!==null&&(r=this.#n.get(e.constructor)),r||(r=this.#o.find(({matches:s})=>s(e))),!r)throw new Error("No encoder found.",{cause:e});let n=r.encode(e,this.encode.bind(this));return{[this.#e]:r.typeId,...n}}decode(e){return this.#t(e)}#t(e,r=!1){switch(typeof e){case"string":case"number":case"boolean":return e;case"object":if(e===null)return null;if(Array.isArray(e))return e.map(n=>this.#t(n));if(this.#e in e&&!Array.isArray(e)&&!r){let n=e[this.#e];if(Array.isArray(n)){if(n.length!==1)throw new Error("Illegal value received. Escaped type identifiers must have exactly one element.",{cause:e});let[d]=n,p={...e};return p[this.#e]=d,this.#t(p,!0)}let s=this.#r.get(n);if(!s)throw new Error(`No decoder found for type id: ${n}`,{cause:e});return s(e,this.decode.bind(this))}if(Object.getPrototypeOf(e)===Object.prototype)return Object.fromEntries(Object.entries(e).map(([n,s])=>[n,this.#t(s)]));break}throw new Error("Illegal value received.",{cause:e})}serialize(e){return this.encode(e)}deserialize(e){return this.decode(e)}stringify(e){return JSON.stringify(this.encode(e))}parse(e){return this.decode(JSON.parse(e))}static default=new t({types:h});static register=t.default.register.bind(t.default);static encode=t.default.encode.bind(t.default);static serialize=t.default.serialize.bind(t.default);static decode=t.default.decode.bind(t.default);static deserialize=t.default.deserialize.bind(t.default);static stringify=t.default.stringify.bind(t.default);static parse=t.default.parse.bind(t.default)};export{i as Jasone,c as bigIntType,o as createType,a as dateType,h as defaultTypes,y as mapType,T as regExpType,f as setType,m as undefinedType,u as urlType};
+var JasoneError=class extends Error{},UnknownTypeIdError=class extends JasoneError{constructor(typeId,value){super(`Unknown type id: ${typeId}`,{cause:value})}},NonJsonValueError=class extends JasoneError{constructor(value){super(`Non-JSON value received`,{cause:value})}},IllegalEncoderResultError=class extends JasoneError{constructor(value){super(`Illegal encoder result received: The encoder result cannot contains the type identifer.`,{cause:value})}},UnhandledValueError=class extends JasoneError{constructor(value){super(`Unhandled value received: No encoder found for this value.`,{cause:value})}},DuplicatedTypeIdError=class extends JasoneError{constructor(typeId,decoder){super(`Duplicated type id: The TypeId<${JSON.stringify(typeId)}> is already registered.`,{cause:decoder})}};let TypeIdRegistry=function(TypeIdRegistry$1){return TypeIdRegistry$1[TypeIdRegistry$1.Undefined=0]=`Undefined`,TypeIdRegistry$1[TypeIdRegistry$1.Date=1]=`Date`,TypeIdRegistry$1[TypeIdRegistry$1.BigInt=2]=`BigInt`,TypeIdRegistry$1[TypeIdRegistry$1.RegExp=3]=`RegExp`,TypeIdRegistry$1[TypeIdRegistry$1.Set=4]=`Set`,TypeIdRegistry$1[TypeIdRegistry$1.Map=5]=`Map`,TypeIdRegistry$1[TypeIdRegistry$1.URL=6]=`URL`,TypeIdRegistry$1}({});const bigIntTransformer={encoder:{filter:{bigint:!0},handler:({value})=>[TypeIdRegistry.BigInt,{bigint:value.toString()}]},decoder:{filter:TypeIdRegistry.BigInt,handler:({value})=>BigInt(value.bigint)}},dateTransformer={encoder:{filter:{class:Date,object:obj=>obj instanceof Date},handler:({value})=>[TypeIdRegistry.Date,{iso:value.toISOString()}]},decoder:{filter:TypeIdRegistry.Date,handler:({value})=>new Date(value.iso)}},mapTransformer={encoder:{filter:{class:Map,object:obj=>obj instanceof Map},handler:({value,jasone})=>[TypeIdRegistry.Map,{entries:value.entries().map(([key,val])=>[jasone.encode(key),jasone.encode(val)]).toArray()}]},decoder:{filter:TypeIdRegistry.Map,handler:({value,jasone})=>new Map(value.entries.map(([key,val])=>[jasone.decode(key),jasone.decode(val)]))}},regExpTransformer={encoder:{filter:{class:RegExp,object:obj=>obj instanceof RegExp},handler:({value})=>[TypeIdRegistry.RegExp,{source:value.source,flags:value.flags}]},decoder:{filter:TypeIdRegistry.RegExp,handler:({value})=>new RegExp(value.source,value.flags)}},setTransformer={encoder:{filter:{class:Set,object:obj=>obj instanceof Set},handler:({value,jasone})=>[TypeIdRegistry.Set,{values:value.values().map(entry=>jasone.encode(entry)).toArray()}]},decoder:{filter:TypeIdRegistry.Set,handler:({value,jasone})=>new Set(value.values.map(entry=>jasone.decode(entry)))}},undefinedTransformer={encoder:{filter:{undefined:!0},handler:()=>[TypeIdRegistry.Undefined,{}]},decoder:{filter:TypeIdRegistry.Undefined,handler:()=>void 0}},urlTransformer={encoder:{filter:{class:URL,object:obj=>obj instanceof URL},handler:({value})=>[TypeIdRegistry.URL,{url:value.toString()}]},decoder:{filter:TypeIdRegistry.URL,handler:({value})=>new URL(value.url)}},defaultTransformers=[undefinedTransformer,dateTransformer,bigIntTransformer,regExpTransformer,setTransformer,mapTransformer,urlTransformer],nonJsonTypes=[`bigint`,`function`,`object`,`symbol`,`undefined`],matchEncoderFilters=(filterInput,value)=>{if(!filterInput)return!0;let filters=Array.isArray(filterInput)?filterInput:[filterInput],type=typeof value;for(let filter of filters){if(filter.any?.(value)||type===`object`&&value!==null&&filter.class===value.constructor)return!0;for(let field of nonJsonTypes){if(type!==field)continue;let typeFilter=filter[field];if(typeFilter===!0||typeFilter?.(value))return!0}}return!1},matchDecoderFilters=(filterInput,value,typeId)=>{if(filterInput===void 0)return!0;let filters=Array.isArray(filterInput)?filterInput:[filterInput];for(let filter of filters)if(typeof filter==`function`&&filter(typeId,value)||filter===typeId)return!0;return!1};var Jasone=class Jasone{#typeIdentifier;#anyDecoder=[];#typeIdDecoder=new Map;#anyEncoder=[];#classEncoder=new Map;#customEncoder={bigint:[],function:[],object:[],symbol:[],undefined:[]};constructor(options={}){this.#typeIdentifier=options.typeIdentifier??`$`;for(let transformer of options.types??[])this.register(transformer)}#registerEncoder(encoder){let filters=encoder.filter?Array.isArray(encoder.filter)?encoder.filter:[encoder.filter]:[];filters.length===0&&this.#anyEncoder.push(encoder);for(let filter of filters){if(filter.any&&this.#anyEncoder.push(encoder),filter.class){let classList=this.#classEncoder.get(filter.class);classList||(classList=[],this.#classEncoder.set(filter.class,classList)),classList.push(encoder)}for(let field of Object.keys(filter))nonJsonTypes.includes(field)&&filter[field]&&this.#customEncoder[field].push(encoder)}}#registerDecoder(decoder){let filters=decoder.filter?Array.isArray(decoder.filter)?decoder.filter:[decoder.filter]:[];filters.length===0&&this.#anyDecoder.push(decoder);for(let filter of filters){if(typeof filter==`function`){this.#anyDecoder.push(decoder);continue}if(this.#typeIdDecoder.has(filter))throw new DuplicatedTypeIdError(filter,decoder);this.#typeIdDecoder.set(filter,decoder)}}register(transformer){transformer.encoder&&this.#registerEncoder(transformer.encoder),transformer.decoder&&this.#registerDecoder(transformer.decoder)}encode(value){let type=typeof value;switch(type){case`boolean`:case`number`:case`string`:return value;case`object`:if(value===null)return null;if(Array.isArray(value))return value.map(entry=>this.encode(entry));if(Object.getPrototypeOf(value)===Object.prototype){let encodedObject=Object.fromEntries(Object.entries(value).map(([key,inner])=>[key,this.encode(inner)]));return this.#typeIdentifier in encodedObject&&(encodedObject[this.#typeIdentifier]=[encodedObject[this.#typeIdentifier]]),encodedObject}}let encoder;if(type===`object`&&(encoder??=this.#classEncoder.get(value.constructor)?.find(inner=>matchEncoderFilters(inner.filter,value))),encoder??=this.#customEncoder[type].find(inner=>matchEncoderFilters(inner.filter,value)),encoder??=this.#anyEncoder.find(inner=>matchEncoderFilters(inner.filter,value)),!encoder)throw new UnhandledValueError(value);let[typeId,result]=encoder.handler({value,jasone:this});if(typeId!==null&&this.#typeIdentifier in result)throw new IllegalEncoderResultError(result);return typeId===null?result:{[this.#typeIdentifier]:typeId,...result}}decode(value){return this.#decode(value)}#decode(value,ignoreTypeIdentifier=!1){switch(typeof value){case`boolean`:case`number`:case`string`:return value;case`object`:if(value===null)return null;if(Array.isArray(value))return value.map(inner=>this.#decode(inner));if(this.#typeIdentifier in value&&!Array.isArray(value)&&!ignoreTypeIdentifier){let typeId=value[this.#typeIdentifier];if(Array.isArray(typeId)){let[escaped]=typeId,cloned={...value};return cloned[this.#typeIdentifier]=escaped,this.#decode(cloned,!0)}let decoder;if(decoder??=this.#typeIdDecoder.get(typeId),decoder??=this.#anyDecoder.find(entry=>matchDecoderFilters(entry.filter,value,typeId)),!decoder)throw new UnknownTypeIdError(typeId,value);return decoder.handler({typeId,value,jasone:this})}if(Object.getPrototypeOf(value)===Object.prototype)return Object.fromEntries(Object.entries(value).map(([key,inner])=>[key,this.#decode(inner)]));break}throw new NonJsonValueError(value)}serialize(value){return this.encode(value)}deserialize(value){return this.decode(value)}stringify(value){return JSON.stringify(this.encode(value))}parse(value){return this.decode(JSON.parse(value))}static default=new Jasone({types:defaultTransformers});static encode=Jasone.default.encode.bind(Jasone.default);static serialize=Jasone.default.serialize.bind(Jasone.default);static decode=Jasone.default.decode.bind(Jasone.default);static deserialize=Jasone.default.deserialize.bind(Jasone.default);static stringify=Jasone.default.stringify.bind(Jasone.default);static parse=Jasone.default.parse.bind(Jasone.default);static register=Jasone.default.register.bind(Jasone.default)};export{Jasone,defaultTransformers,nonJsonTypes};

package/package.json

@@ -1,17 +1,15 @@
 {
   "name": "jasone",
-  "version": "0.0.4",
+  "version": "1.0.0-beta.0",
   "type": "module",
   "author": "Lukas Heizmann <lukas@heizmann.dev>",
   "license": "MIT",
-  "main": "./index.cjs",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": "./index.js",
-      "require": "./index.cjs",
-      "types": "./index.d.ts"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     }
   },
   "repository": {

package/index.cjs

@@ -1 +0,0 @@
-"use strict";var c=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var I=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var w=(t,e)=>{for(var r in e)c(t,r,{get:e[r],enumerable:!0})},J=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of I(e))!b.call(t,o)&&o!==r&&c(t,o,{get:()=>e[o],enumerable:!(n=g(e,o))||n.enumerable});return t};var x=t=>J(c({},"__esModule",{value:!0}),t);var E={};w(E,{Jasone:()=>d,bigIntType:()=>a,createType:()=>s,dateType:()=>y,defaultTypes:()=>l,mapType:()=>T,regExpType:()=>f,setType:()=>m,undefinedType:()=>u,urlType:()=>h});module.exports=x(E);var s=t=>t;var a=s({matches:t=>typeof t=="bigint",typeId:2,encode:t=>({bigint:t.toString()}),decode:({bigint:t})=>BigInt(t)});var y=s({target:Date,typeId:1,encode:t=>({timestamp:t.getTime()}),decode:({timestamp:t})=>new Date(t)});var T=s({target:Map,typeId:5,encode:(t,e)=>({map:Array.from(t.entries().map(([r,n])=>[e(r),e(n)]))}),decode:({map:t},e)=>new Map(t.map(([r,n])=>{if(r===void 0||n===void 0)throw new Error("Illegal value received.",{cause:t});return[e(r),e(n)]}))});var f=s({target:RegExp,typeId:3,encode:t=>({source:t.source,flags:t.flags}),decode:({source:t,flags:e})=>new RegExp(t,e)});var m=s({target:Set,typeId:4,encode:(t,e)=>({set:Array.from(t.values().map(r=>e(r)))}),decode:({set:t},e)=>new Set(t.map(r=>e(r)))});var u=s({matches:t=>t===void 0,typeId:0,encode:()=>({}),decode:()=>{}});var h=s({target:URL,typeId:6,encode:t=>({url:t.toString()}),decode:({url:t})=>new URL(t)});var l=[u,y,a,f,m,T,h];var d=class t{#e;#r=new Map;#n=new Map;#o=[];constructor(e={}){this.#e=e.typeIdentifier??"$";for(let r of e.types??[])this.register(r)}register(e){this.#r.set(e.typeId,e.decode),"matches"in e?this.#o.push({matches:e.matches,typeId:e.typeId,encode:e.encode}):this.#n.set(e.target,{typeId:e.typeId,encode:e.encode})}encode(e){switch(typeof e){case"string":case"number":case"boolean":return e;case"object":if(e===null)return null;if(Array.isArray(e))return e.map(o=>this.encode(o));if(Object.getPrototypeOf(e)===Object.prototype){let o=Object.fromEntries(Object.entries(e).map(([i,p])=>[i,this.encode(p)]));return this.#e in o&&(o[this.#e]=[this.encode(o[this.#e])]),o}}let r;if(typeof e=="object"&&e!==null&&(r=this.#n.get(e.constructor)),r||(r=this.#o.find(({matches:o})=>o(e))),!r)throw new Error("No encoder found.",{cause:e});let n=r.encode(e,this.encode.bind(this));return{[this.#e]:r.typeId,...n}}decode(e){return this.#t(e)}#t(e,r=!1){switch(typeof e){case"string":case"number":case"boolean":return e;case"object":if(e===null)return null;if(Array.isArray(e))return e.map(n=>this.#t(n));if(this.#e in e&&!Array.isArray(e)&&!r){let n=e[this.#e];if(Array.isArray(n)){if(n.length!==1)throw new Error("Illegal value received. Escaped type identifiers must have exactly one element.",{cause:e});let[i]=n,p={...e};return p[this.#e]=i,this.#t(p,!0)}let o=this.#r.get(n);if(!o)throw new Error(`No decoder found for type id: ${n}`,{cause:e});return o(e,this.decode.bind(this))}if(Object.getPrototypeOf(e)===Object.prototype)return Object.fromEntries(Object.entries(e).map(([n,o])=>[n,this.#t(o)]));break}throw new Error("Illegal value received.",{cause:e})}serialize(e){return this.encode(e)}deserialize(e){return this.decode(e)}stringify(e){return JSON.stringify(this.encode(e))}parse(e){return this.decode(JSON.parse(e))}static default=new t({types:l});static register=t.default.register.bind(t.default);static encode=t.default.encode.bind(t.default);static serialize=t.default.serialize.bind(t.default);static decode=t.default.decode.bind(t.default);static deserialize=t.default.deserialize.bind(t.default);static stringify=t.default.stringify.bind(t.default);static parse=t.default.parse.bind(t.default)};0&&(module.exports={Jasone,bigIntType,createType,dateType,defaultTypes,mapType,regExpType,setType,undefinedType,urlType});

package/index.d.cts

@@ -1,273 +0,0 @@
-/**
- * A JSON-compatible value.
- */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/**
- * The id of an encoded type to identify it on decoding.
- */
-type TypeId = string | number;
-/**
- * A function that is responsible to encode a type into a JSON-compatible value.
- *
- * @param value The value to encode.
- * @param encode A function that works exactly the same as `Jasone.encode` useful
- *               to encode values recursively. This function comes from the instance
- *               where the type transformer is registered, so it has the same types.
- * @returns A JSON-compatible value.
- */
-type TypeEncoder<TType = unknown, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = (value: TType, encode: <T = unknown>(value: T) => JsonValue) => TJson;
-/**
- * A function that is responsible to decode a type back to its decoded value.
- *
- * @param value The value to decode.
- * @param encode A function that works exactly the same as `Jasone.decode` useful
- *               to decode values recursively. This function comes from the instance
- *               where the type transformer is registered, so it has the same types.
- * @returns A JSON-compatible value.
- */
-type TypeDecoder<TType = unknown, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = (value: TJson, decode: <T = unknown>(value: JsonValue) => T) => TType;
-type MatchesFn<TType = unknown> = (value: unknown) => value is TType;
-type ClassLike<TInstance> = new <T>(...args: any[]) => TInstance;
-declare const typeOf: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-type TypeOf = typeof typeOf;
-
-type TypeMatcher<TType> = {
-    /**
-     * The function that is responsible to determine if a value can be
-     * encoded with this transformer.
-     */
-    matches: MatchesFn<TType>;
-} | {
-    /**
-     * The class that can be encoded with this transformer.
-     *
-     * Using the `target` property only works on classes with an
-     * `constructor`. Internally, Jasone matches the constructor of the
-     * class with the `target` property.
-     */
-    target: ClassLike<TType>;
-};
-/**
- * A type transformer which is responsible for encoding and decoding a type.
- */
-type TypeTransformer<TType, TJson extends Record<string, JsonValue> = Record<string, JsonValue>> = TypeMatcher<TType> & {
-    /**
-     * The id of the type that is used to identify the type on decoding.
-     *
-     * This id should be unique for each type and it is recommended to use strings
-     * to avoid conflicts with built-in types (which used positive integers).
-     */
-    typeId: string | number;
-    /**
-     * The function that is responsible to encode the type into a JSON-compatible
-     * value.
-     */
-    encode: TypeEncoder<TType, TJson>;
-    /**
-     * The function that is responsible to decode the type from a JSON-compatible
-     * value.
-     */
-    decode: TypeDecoder<TType, TJson>;
-};
-/**
- * A convenience function to create a type transformer which automatically
- * infer the types for you, so you don't have to.
- *
- * @param transformer The transformer to create.
- * @returns The exact same transformer you passed in, but with the types inferred.
- */
-declare const createType: <TType, TJson extends Record<string, JsonValue>>(transformer: TypeTransformer<TType, TJson>) => TypeTransformer<TType, TJson>;
-
-declare const bigIntType: TypeTransformer<bigint, {
-    bigint: string;
-}>;
-
-declare const dateType: TypeTransformer<Date, {
-    timestamp: number;
-}>;
-
-declare const mapType: TypeTransformer<Map<unknown, unknown>, {
-    map: JsonValue[][];
-}>;
-
-declare const regExpType: TypeTransformer<RegExp, {
-    source: string;
-    flags: string;
-}>;
-
-declare const setType: TypeTransformer<Set<unknown>, {
-    set: JsonValue[];
-}>;
-
-declare const undefinedType: TypeTransformer<undefined, {}>;
-
-declare const urlType: TypeTransformer<URL, {
-    url: string;
-}>;
-
-/**
- * The default types that are used by the default Jasone instance.
- */
-declare const defaultTypes: TypeTransformer<any, any>[];
-
-/**
- * Jasone options that can be passed to the Jasone constructor.
- */
-type JasoneOptions = {
-    /**
-     * The type identifier that is used to determine if an object is a typed object.
-     *
-     * @default "$"
-     */
-    typeIdentifier?: string;
-    /**
-     * The types that are used to encode and decode objects.
-     *
-     * If not provided, the default types are used. By providing your own types,
-     * the default types are not used anymore, so be sure to also include them.
-     *
-     * @example
-     * ```ts
-     * // your custom type WITH default types
-     * const jasone = new Jasone({ types: [myCustomType, ...defaultTypes] });
-     *
-     * // your custom type WITHOUT default types
-     * const jasone = new Jasone({ types: [myCustomType] });
-     * ```
-     */
-    types?: TypeTransformer<any, any>[];
-};
-/**
- * Jasone is a JSON encoder and decoder that can handle custom types.
- *
- * It exposes the default Jasone instance as `Jasone.default` and also
- * registers the methods as static methods on the class itself, so you
- * can easily use them without having to create an instance.
- *
- * ```ts
- * const encoded = Jasone.encode(value);
- * const decoded = Jasone.decode(value);
- * ```
- *
- * If you want to use your own types, you can either register them on any
- * instance (even on `Jasone.default`) or instantiate your own Jasone instance.
- *
- * ```ts
- * // use our own types without the default types (Date, BigInt, Map, etc.)
- * const myInstance = new Jasone({ types: [myCustomType] });
- *
- * // or use our own types with the default types (recommend)
- * const myInstance = new Jasone({ types: [myCustomType, ...defaultTypes] });
- *
- * const encoded = myInstance.encode(value);
- * const decoded = myInstance.decode(value);
- * ```
- */
-declare class Jasone {
-    #private;
-    constructor(options?: JasoneOptions);
-    /**
-     * Register a new type to this Jasone instance.
-     *
-     * @param type The type to register.
-     */
-    register<TType, TJson extends Record<string, JsonValue>>(type: TypeTransformer<TType, TJson>): void;
-    /**
-     * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
-     *
-     * @param value The value to encode.
-     * @returns A JSON-compatible Jasone encoded value.
-     */
-    encode(value: unknown): JsonValue;
-    /**
-     * Decode an Jasone encoded value to its decoded value.
-     *
-     * @param value The Jasone encoded value to decode.
-     * @returns The decoded value.
-     */
-    decode<T = unknown>(value: JsonValue): T;
-    /**
-     * Alias for `encode`.
-     */
-    serialize(value: unknown): JsonValue;
-    /**
-     * Alias for `decode`.
-     */
-    deserialize<T = unknown>(value: JsonValue): T;
-    /**
-     * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * JSON.stringify(this.encode(value));
-     * ```
-     */
-    stringify(value: unknown): string;
-    /**
-     * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * this.decode(JSON.parse(value));
-     * ```
-     */
-    parse<T = unknown>(value: string): T;
-    /**
-     * The default Jasone instance with the default types already registered.
-     */
-    static default: Jasone;
-    /**
-     * Register a new type to the default Jasone instance.
-     *
-     * @param type The type to register.
-     */
-    static register: <TType, TJson extends Record<string, JsonValue>>(type: TypeTransformer<TType, TJson>) => void;
-    /**
-     * Encode an arbitrary value to a JSON-compatible Jasone encoded value.
-     *
-     * @param value The value to encode.
-     * @returns A JSON-compatible Jasone encoded value.
-     */
-    static encode: (value: unknown) => JsonValue;
-    /**
-     * Alias for `encode`.
-     */
-    static serialize: (value: unknown) => JsonValue;
-    /**
-     * Decode an Jasone encoded value to its decoded value.
-     *
-     * @param value The Jasone encoded value to decode.
-     * @returns The decoded value.
-     */
-    static decode: <T = unknown>(value: JsonValue) => T;
-    /**
-     * Alias for `decode`.
-     */
-    static deserialize: <T = unknown>(value: JsonValue) => T;
-    /**
-     * A wrapper around `JSON.stringify` that encodes a value and stringifies it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * JSON.stringify(Jasone.encode(value));
-     * ```
-     */
-    static stringify: (value: unknown) => string;
-    /**
-     * A wrapper around `JSON.parse` that parses a Jasone encoded value and decodes it.
-     *
-     * Under the hood, this functions looks like this:
-     *
-     * ```ts
-     * Jasone.decode(JSON.parse(value));
-     * ```
-     */
-    static parse: <T = unknown>(value: string) => T;
-}
-
-export { type ClassLike, Jasone, type JasoneOptions, type JsonValue, type MatchesFn, type TypeDecoder, type TypeEncoder, type TypeId, type TypeMatcher, type TypeOf, type TypeTransformer, bigIntType, createType, dateType, defaultTypes, mapType, regExpType, setType, undefinedType, urlType };