yayson 3.0.0 → 4.0.0

package/build/yayson-CRbukIqr.d.mts

@@ -0,0 +1,69 @@
+import { T as ModelLike, _ as ValidationError, d as SchemaRegistry, f as StoreModel, g as StoreResult, h as StoreRecord$1, i as JsonApiLinks, m as StoreOptions, n as JsonApiDocument, o as JsonApiRelationships, p as StoreModels, r as JsonApiLink, t as InferModelType, u as PresenterOptions, w as Adapter } from "./types-BsfPiPEw.mjs";
+
+//#region src/yayson/presenter.d.ts
+declare function createPresenter(adapter: typeof Adapter): {
+  new (scope?: JsonApiDocument): {
+    constructor: /*elided*/any;
+    scope: JsonApiDocument;
+    id(instance: ModelLike): string | undefined;
+    selfLinks(_instance: ModelLike): JsonApiLink | string | undefined;
+    links(_instance?: ModelLike): JsonApiLinks | undefined;
+    relationships(): Record<string, /*elided*/any>;
+    attributes(instance: ModelLike | null): Record<string, unknown>;
+    includeRelationships(scope: JsonApiDocument, instance: ModelLike): unknown[];
+    buildRelationships(instance: ModelLike | null): JsonApiRelationships | null;
+    buildSelfLink(instance: ModelLike): JsonApiLink | undefined;
+    toJSON(instanceOrCollection: ModelLike | ModelLike[] | null | undefined, options?: PresenterOptions): JsonApiDocument;
+    render(instanceOrCollection: ModelLike | ModelLike[] | null, options?: PresenterOptions): JsonApiDocument;
+  };
+  adapter: typeof Adapter;
+  type: string;
+  fields?: string[];
+  toJSON(instanceOrCollection: ModelLike | ModelLike[] | null, options?: PresenterOptions): JsonApiDocument;
+  render(instanceOrCollection: ModelLike | ModelLike[] | null, options?: PresenterOptions): JsonApiDocument;
+};
+type Presenter = ReturnType<typeof createPresenter>;
+//#endregion
+//#region src/yayson/store.d.ts
+declare class StoreRecord implements StoreRecord$1 {
+  id: string | number;
+  type: string;
+  attributes?: Record<string, unknown>;
+  relationships?: JsonApiRelationships;
+  links?: JsonApiLink;
+  meta?: Record<string, unknown>;
+  constructor(options: StoreRecord$1);
+}
+declare class Store<S extends SchemaRegistry = SchemaRegistry> {
+  records: StoreRecord[];
+  schemas?: S;
+  strict: boolean;
+  validationErrors: ValidationError[];
+  constructor(options?: StoreOptions<S>);
+  reset(): void;
+  toModel(rec: StoreRecord, type: string, models: StoreModels): StoreModel;
+  findRecord(type: string, id: string | number): StoreRecord | undefined;
+  findRecords(type: string): StoreRecord[];
+  find<T extends string>(type: T, id: string | number, models?: StoreModels): InferModelType<S, T> | null;
+  findAll<T extends string>(type: T, models?: StoreModels): InferModelType<S, T>[];
+  remove(type: string, id?: string | number): void;
+  syncAll(body: JsonApiDocument): StoreResult;
+  sync(body: JsonApiDocument): StoreModel | StoreResult;
+  retrieve<T extends string>(type: T, body: JsonApiDocument): InferModelType<S, T> | null;
+  retrieveAll<T extends string>(type: T, body: JsonApiDocument): StoreResult<InferModelType<S, T>>;
+}
+//#endregion
+//#region src/yayson.d.ts
+type AdapterOption = string | typeof Adapter;
+interface YaysonOptions {
+  adapter?: AdapterOption;
+}
+interface YaysonResult {
+  Store: typeof Store;
+  Presenter: Presenter;
+  Adapter: typeof Adapter;
+}
+declare function yayson(options?: YaysonOptions): YaysonResult;
+//#endregion
+export { Presenter as i, YaysonResult as n, yayson as r, YaysonOptions as t };
+//# sourceMappingURL=yayson-CRbukIqr.d.mts.map

package/build/yayson-CRbukIqr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yayson-CRbukIqr.d.mts","names":[],"sources":["../../../../../../yayson/presenter.ts","../../../../../../yayson/store.ts","../../../../../../yayson.ts"],"mappings":";;;iBAyBwB,eAAA,CAAgB,OAAA,SAAgB,OAAA;EAAA,aAUhC,eAAA;iBAVe;WAQ5B,eAAA;iBAMM,SAAA;yBAIQ,SAAA,GAAY,WAAA;sBAIf,SAAA,GAAY,YAAA;qBAIb,MAAA,SAZJ;yBAgBQ,SAAA,UAAmB,MAAA;gCAiBZ,eAAA,EAAe,QAAA,EAAY,SAAA;iCAoB1B,SAAA,UAAmB,oBAAA;4BA0DxB,SAAA,GAAY,WAAA;iCAKZ,SAAA,GAAY,SAAA,uBAA8B,OAAA,GACtD,gBAAA,GACT,eAAA;iCA8E0B,SAAA,GAAY,SAAA,WAAkB,OAAA,GAAY,gBAAA,GAAmB,eAAA;EAAA;;;;+BAItD,SAAA,GAAY,SAAA,WAAkB,OAAA,GAAY,gBAAA,GAAmB,eAAA;+BAI7D,SAAA,GAAY,SAAA,WAAkB,OAAA,GAAY,gBAAA,GAAmB,eAAA;AAAA;AAAA,KAQzF,SAAA,GAAY,UAAA,QAAkB,eAAA;;;cC1OpC,WAAA,YAAuB,aAAA;EAC3B,EAAA;EACA,IAAA;EACA,UAAA,GAAa,MAAA;EACb,aAAA,GAAgB,oBAAA;EAChB,KAAA,GAAQ,WAAA;EACR,IAAA,GAAO,MAAA;cAEK,OAAA,EAAS,aAAA;AAAA;AAAA,cAUF,KAAA,WAAgB,cAAA,GAAiB,cAAA;EACpD,OAAA,EAAS,WAAA;EACT,OAAA,GAAU,CAAA;EACV,MAAA;EACA,gBAAA,EAAkB,eAAA;cAEN,OAAA,GAAU,YAAA,CAAa,CAAA;EAMnC,KAAA,CAAA;EAKA,OAAA,CAAQ,GAAA,EAAK,WAAA,EAAa,IAAA,UAAc,MAAA,EAAQ,WAAA,GAAc,UAAA;EA6E9D,UAAA,CAAW,IAAA,UAAc,EAAA,oBAAsB,WAAA;EAK/C,WAAA,CAAY,IAAA,WAAe,WAAA;EAI3B,IAAA,kBAAA,CAAuB,IAAA,EAAM,CAAA,EAAG,EAAA,mBAAqB,MAAA,GAAS,WAAA,GAAc,cAAA,CAAe,CAAA,EAAG,CAAA;EAc9F,OAAA,kBAAA,CAA0B,IAAA,EAAM,CAAA,EAAG,MAAA,GAAS,WAAA,GAAc,cAAA,CAAe,CAAA,EAAG,CAAA;EAgB5E,MAAA,CAAO,IAAA,UAAc,EAAA;EAkBrB,OAAA,CAAQ,IAAA,EAAM,eAAA,GAAkB,WAAA;EA8DhC,IAAA,CAAK,IAAA,EAAM,eAAA,GAAkB,UAAA,GAAa,WAAA;EAY1C,QAAA,kBAAA,CAA2B,IAAA,EAAM,CAAA,EAAG,IAAA,EAAM,eAAA,GAAkB,cAAA,CAAe,CAAA,EAAG,CAAA;EAW9E,WAAA,kBAAA,CAA8B,IAAA,EAAM,CAAA,EAAG,IAAA,EAAM,eAAA,GAAkB,WAAA,CAAY,cAAA,CAAe,CAAA,EAAG,CAAA;AAAA;;;KC5P1F,aAAA,mBAAgC,OAAA;AAAA,UAE3B,aAAA;EACR,OAAA,GAAU,aAAA;AAAA;AAAA,UAGF,YAAA;EACR,KAAA,SAAc,KAAA;EACd,SAAA,EAAW,SAAA;EACX,OAAA,SAAgB,OAAA;AAAA;AAAA,iBAgBT,MAAA,CAAO,OAAA,GAAU,aAAA,GAAgB,YAAA"}

package/build/yayson-CUfrxK9d.cjs

@@ -0,0 +1,407 @@
+const require_symbols = require('./symbols-nFs99aEX.cjs');
+
+//#region src/yayson/adapters/sequelize.ts
+function isSequelizeModel(model) {
+	return model != null && typeof model === "object" && "get" in model && typeof model.get === "function";
+}
+var SequelizeAdapter = class extends require_symbols.adapter_default {
+	static get(model, key) {
+		if (isSequelizeModel(model)) return model.get(key);
+	}
+	static id(model) {
+		const pkFields = model.constructor && "primaryKeys" in model.constructor ? Object.keys(model.constructor.primaryKeys) : ["id"];
+		if (pkFields.length > 1) throw new Error("YAYSON does not support Sequelize models with composite primary keys. You can only use one column for your primary key. Currently using: " + pkFields.join(","));
+		else if (pkFields.length < 1) throw new Error("YAYSON can only serialize Sequelize models which have a primary key. This is used for the JSON:API model id.");
+		const id = this.get(model, pkFields[0]);
+		if (id === void 0) return id;
+		return `${id}`;
+	}
+};
+var sequelize_default = SequelizeAdapter;
+
+//#endregion
+//#region src/yayson/utils.ts
+/**
+* Filters an attributes object to only include keys in the fields array.
+* Returns the original attributes if fields is undefined.
+*/
+function filterByFields(attributes, fields) {
+	if (!fields) return attributes;
+	const filtered = {};
+	for (const key of fields) if (key in attributes) filtered[key] = attributes[key];
+	return filtered;
+}
+
+//#endregion
+//#region src/yayson/presenter.ts
+function buildLinks(link) {
+	if (link == null) return;
+	if (typeof link === "object" && (link.self != null || link.related != null)) return link;
+	else return { self: String(link) };
+}
+function createPresenter(adapter) {
+	class Presenter {
+		static adapter = adapter;
+		static type = "objects";
+		static fields;
+		scope;
+		constructor(scope) {
+			this.scope = scope ?? { data: null };
+		}
+		id(instance) {
+			return this.constructor.adapter.id(instance);
+		}
+		selfLinks(_instance) {}
+		links(_instance) {}
+		relationships() {
+			return {};
+		}
+		attributes(instance) {
+			if (instance == null) return {};
+			const attributes = { ...this.constructor.adapter.get(instance) };
+			delete attributes["id"];
+			const relationships = this.relationships();
+			if (relationships) for (const key in relationships) delete attributes[key];
+			return filterByFields(attributes, this.constructor.fields);
+		}
+		includeRelationships(scope, instance) {
+			const relationships = this.relationships();
+			const result = [];
+			if (!relationships) return result;
+			for (const key in relationships) {
+				const factory = relationships[key];
+				if (!factory) throw new Error(`Presenter for ${key} in ${this.constructor.type} is not defined`);
+				const presenter = new factory(scope);
+				const data = this.constructor.adapter.get(instance, key);
+				result.push(presenter.toJSON(data, { include: true }));
+			}
+			return result;
+		}
+		buildRelationships(instance) {
+			if (instance == null) return null;
+			const rels = this.relationships();
+			const links = this.links(instance) || {};
+			let relationships = null;
+			if (!rels) return null;
+			for (const key in rels) {
+				const data = this.constructor.adapter.get(instance, key);
+				const presenter = rels[key];
+				const buildData = (d) => {
+					const id = this.constructor.adapter.id(d);
+					if (!id) throw new Error(`Model of type ${presenter.type} is missing an id (relationship '${key}' of ${this.constructor.type})`);
+					return {
+						id,
+						type: presenter.type
+					};
+				};
+				const build = (d) => {
+					const rel = {};
+					if (d != null) rel.data = buildData(d);
+					if (links[key] != null) rel.links = buildLinks(links[key]);
+					else if (d == null) rel.data = null;
+					return rel;
+				};
+				if (!relationships) relationships = {};
+				if (!relationships[key]) relationships[key] = {};
+				if (Array.isArray(data)) {
+					relationships[key].data = data.map(buildData);
+					if (links[key] != null) relationships[key].links = buildLinks(links[key]);
+				} else relationships[key] = build(data);
+			}
+			return relationships;
+		}
+		buildSelfLink(instance) {
+			return buildLinks(this.selfLinks(instance));
+		}
+		toJSON(instanceOrCollection, options) {
+			const opts = options ?? {};
+			if (opts.meta != null) this.scope.meta = opts.meta;
+			if (opts.links != null) this.scope.links = opts.links;
+			if (!this.scope.data) this.scope.data = null;
+			if (instanceOrCollection == null) return this.scope;
+			if (Array.isArray(instanceOrCollection)) {
+				const collection = instanceOrCollection;
+				if (!this.scope.data) this.scope.data = [];
+				collection.forEach((instance) => {
+					return this.toJSON(instance, options);
+				});
+			} else {
+				const instance = instanceOrCollection;
+				let added = true;
+				const model = {
+					id: this.id(instance),
+					type: this.constructor.type,
+					attributes: this.attributes(instance)
+				};
+				if (model.id === void 0) delete model.id;
+				const relationships = this.buildRelationships(instance);
+				if (relationships != null) model.relationships = relationships;
+				const links = this.buildSelfLink(instance);
+				if (links != null) model.links = links;
+				if (opts.include) {
+					if (!this.scope.included) this.scope.included = [];
+					if (!(this.scope.included || []).concat(Array.isArray(this.scope.data) ? this.scope.data : this.scope.data ? [this.scope.data] : []).some((i) => i.id === model.id && i.type === model.type)) this.scope.included.push(model);
+					else added = false;
+				} else if (this.scope.data != null) if (Array.isArray(this.scope.data)) if (!this.scope.data.some((i) => i.id === model.id && i.type === model.type)) this.scope.data.push(model);
+				else added = false;
+				else this.scope.data = model;
+				else this.scope.data = model;
+				if (added) this.includeRelationships(this.scope, instance);
+			}
+			return this.scope;
+		}
+		render(instanceOrCollection, options) {
+			return this.toJSON(instanceOrCollection, options);
+		}
+		static toJSON(instanceOrCollection, options) {
+			return new this().toJSON(instanceOrCollection, options);
+		}
+		static render(instanceOrCollection, options) {
+			return new this().render(instanceOrCollection, options);
+		}
+	}
+	return Presenter;
+}
+
+//#endregion
+//#region src/yayson/schema.ts
+function isZodLikeSchema(schema) {
+	return schema != null && typeof schema === "object" && "parse" in schema && typeof schema.parse === "function" && "safeParse" in schema && typeof schema.safeParse === "function";
+}
+function validate(schema, data, strict) {
+	if (!isZodLikeSchema(schema)) throw new Error("Invalid schema: must have parse and safeParse methods");
+	if (strict) return {
+		valid: true,
+		data: schema.parse(data)
+	};
+	else {
+		const result = schema.safeParse(data);
+		if (result.success) return {
+			valid: true,
+			data: result.data
+		};
+		else return {
+			valid: false,
+			data,
+			error: result.error
+		};
+	}
+}
+
+//#endregion
+//#region src/yayson/store.ts
+var StoreRecord = class {
+	id;
+	type;
+	attributes;
+	relationships;
+	links;
+	meta;
+	constructor(options) {
+		this.id = options.id;
+		this.type = options.type;
+		this.attributes = options.attributes;
+		this.relationships = options.relationships;
+		this.links = options.links;
+		this.meta = options.meta;
+	}
+};
+var Store = class {
+	records = [];
+	schemas;
+	strict;
+	validationErrors = [];
+	constructor(options) {
+		this.schemas = options?.schemas;
+		this.strict = options?.strict ?? false;
+		this.reset();
+	}
+	reset() {
+		this.records = [];
+		this.validationErrors = [];
+	}
+	toModel(rec, type, models) {
+		const model = {
+			...rec.attributes || {},
+			id: rec.id
+		};
+		model[require_symbols.TYPE] = rec.type;
+		const idStr = String(rec.id);
+		if (!models[type]) models[type] = {};
+		if (!models[type][idStr]) models[type][idStr] = model;
+		if (rec.meta != null) model[require_symbols.META] = rec.meta;
+		if (rec.links != null) model[require_symbols.LINKS] = rec.links;
+		if (rec.relationships != null) for (const key in rec.relationships) {
+			const rel = rec.relationships[key];
+			const { data } = rel;
+			const { links } = rel;
+			const { meta } = rel;
+			model[key] = null;
+			if (data == null && links == null) continue;
+			const resolve = ({ type: type$1, id }) => {
+				return this.find(type$1, id, models);
+			};
+			if (Array.isArray(data)) model[key] = data.map(resolve);
+			else {
+				const relModel = data != null ? resolve(data) : { id: "" };
+				if (relModel) {
+					relModel[require_symbols.REL_LINKS] = links || {};
+					relModel[require_symbols.REL_META] = meta || {};
+					model[key] = relModel;
+				}
+			}
+		}
+		if (this.schemas && this.schemas[rec.type]) {
+			const schema = this.schemas[rec.type];
+			const result = validate(schema, model, this.strict);
+			if (!result.valid) this.validationErrors.push({
+				type: rec.type,
+				id: rec.id,
+				error: result.error
+			});
+			const validatedModel = result.data;
+			validatedModel[require_symbols.TYPE] = model[require_symbols.TYPE];
+			validatedModel[require_symbols.LINKS] = model[require_symbols.LINKS];
+			validatedModel[require_symbols.META] = model[require_symbols.META];
+			return validatedModel;
+		}
+		return model;
+	}
+	findRecord(type, id) {
+		const idStr = String(id);
+		return this.records.find((r) => r.type === type && String(r.id) === idStr);
+	}
+	findRecords(type) {
+		return this.records.filter((r) => r.type === type);
+	}
+	find(type, id, models) {
+		const modelsObj = models ?? {};
+		const idStr = String(id);
+		const rec = this.findRecord(type, idStr);
+		if (rec == null) return null;
+		if (!modelsObj[type]) modelsObj[type] = {};
+		return modelsObj[type][idStr] || this.toModel(rec, type, modelsObj);
+	}
+	findAll(type, models) {
+		const modelsObj = models ?? {};
+		const recs = this.findRecords(type);
+		if (recs == null) return [];
+		recs.forEach((rec) => {
+			if (!modelsObj[type]) modelsObj[type] = {};
+			return this.toModel(rec, type, modelsObj);
+		});
+		return Object.values(modelsObj[type] || {});
+	}
+	remove(type, id) {
+		const removeOne = (record) => {
+			const index = this.records.indexOf(record);
+			if (!(index < 0)) this.records.splice(index, 1);
+		};
+		if (id != null) {
+			const record = this.findRecord(type, String(id));
+			if (record) removeOne(record);
+		} else this.findRecords(type).forEach(removeOne);
+	}
+	syncAll(body) {
+		this.validationErrors = [];
+		const previousRecords = [...this.records];
+		const syncData = (data) => {
+			if (data == null) return [];
+			const add = (obj) => {
+				const { type, id } = obj;
+				this.remove(type, id);
+				const rec = new StoreRecord(obj);
+				this.records.push(rec);
+				return rec;
+			};
+			if (Array.isArray(data)) return data.map((item) => {
+				if (!item.id) throw new Error(`Resource of type ${item.type} is missing an id`);
+				return add({
+					...item,
+					attributes: item.attributes ?? void 0,
+					relationships: item.relationships ?? void 0,
+					id: item.id
+				});
+			});
+			else {
+				if (!data.id) throw new Error(`Resource of type ${data.type} is missing an id`);
+				return [add({
+					...data,
+					attributes: data.attributes ?? void 0,
+					relationships: data.relationships ?? void 0,
+					id: data.id
+				})];
+			}
+		};
+		try {
+			syncData(body.included);
+			const recs = syncData(body.data);
+			const models = {};
+			const result = recs.map((rec) => this.toModel(rec, rec.type, models));
+			if (body.meta != null) result[require_symbols.META] = body.meta;
+			return result;
+		} catch (e) {
+			this.records = previousRecords;
+			throw e;
+		}
+	}
+	sync(body) {
+		const result = this.syncAll(body);
+		if (!Array.isArray(body.data) && body.data != null) {
+			const model = result[0];
+			if (result[require_symbols.META]) model[require_symbols.META] = result[require_symbols.META];
+			return model;
+		}
+		return result;
+	}
+	retrieve(type, body) {
+		const synced = this.syncAll(body);
+		const model = synced.find((m) => m[require_symbols.TYPE] === type);
+		if (!model) return null;
+		if (synced[require_symbols.META]) model[require_symbols.META] = synced[require_symbols.META];
+		return model;
+	}
+	retrieveAll(type, body) {
+		const synced = this.syncAll(body);
+		const result = synced.filter((model) => model[require_symbols.TYPE] === type);
+		result[require_symbols.META] = synced[require_symbols.META];
+		return result;
+	}
+};
+
+//#endregion
+//#region src/yayson.ts
+function lookupAdapter(nameOrAdapter) {
+	if (nameOrAdapter === "default" || !nameOrAdapter) return require_symbols.adapter_default;
+	else if (typeof nameOrAdapter === "string") if (nameOrAdapter === "sequelize") return sequelize_default;
+	else throw new Error("Adapter not found: " + nameOrAdapter);
+	return nameOrAdapter;
+}
+function yayson(options) {
+	return {
+		Store,
+		Presenter: createPresenter(lookupAdapter(options?.adapter)),
+		Adapter: require_symbols.adapter_default
+	};
+}
+var yayson_default = yayson;
+
+//#endregion
+Object.defineProperty(exports, 'filterByFields', {
+  enumerable: true,
+  get: function () {
+    return filterByFields;
+  }
+});
+Object.defineProperty(exports, 'validate', {
+  enumerable: true,
+  get: function () {
+    return validate;
+  }
+});
+Object.defineProperty(exports, 'yayson_default', {
+  enumerable: true,
+  get: function () {
+    return yayson_default;
+  }
+});

package/build/yayson.cjs

@@ -0,0 +1,3 @@
+const require_yayson = require('./yayson-CUfrxK9d.cjs');
+
+module.exports = require_yayson.yayson_default;

package/build/yayson.d.cts

@@ -0,0 +1,3 @@
+import { _ as ValidationError, a as JsonApiRelationship, d as SchemaRegistry, i as JsonApiLinks, l as LegacyStoreOptions, m as StoreOptions, n as JsonApiDocument, o as JsonApiRelationships, r as JsonApiLink, s as JsonApiResource, u as PresenterOptions, v as ZodLikeSchema, w as Adapter } from "./types-DbMIe8E2.cjs";
+import { n as YaysonResult, r as yayson, t as YaysonOptions } from "./yayson-BKEyEcGk.cjs";
+export { Adapter, JsonApiDocument, JsonApiLink, JsonApiLinks, JsonApiRelationship, JsonApiRelationships, JsonApiResource, LegacyStoreOptions, PresenterOptions, SchemaRegistry, StoreOptions, ValidationError, YaysonOptions, YaysonResult, ZodLikeSchema, yayson as default };

package/build/yayson.d.mts

@@ -0,0 +1,3 @@
+import { _ as ValidationError, a as JsonApiRelationship, d as SchemaRegistry, i as JsonApiLinks, l as LegacyStoreOptions, m as StoreOptions, n as JsonApiDocument, o as JsonApiRelationships, r as JsonApiLink, s as JsonApiResource, u as PresenterOptions, v as ZodLikeSchema, w as Adapter } from "./types-BsfPiPEw.mjs";
+import { n as YaysonResult, r as yayson, t as YaysonOptions } from "./yayson-CRbukIqr.mjs";
+export { Adapter, JsonApiDocument, JsonApiLink, JsonApiLinks, JsonApiRelationship, JsonApiRelationships, JsonApiResource, LegacyStoreOptions, PresenterOptions, SchemaRegistry, StoreOptions, ValidationError, YaysonOptions, YaysonResult, ZodLikeSchema, yayson as default };

package/build/yayson.mjs

@@ -0,0 +1,3 @@
+import { t as yayson_default } from "./yayson-BJv2Z0Z6.mjs";
+
+export { yayson_default as default };

package/package.json

@@ -1,19 +1,63 @@
 {
   "name": "yayson",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "A library for serializing and reading JSON API standardized data in JavaScript.",
-  "main": "src/yayson.js",
+  "type": "module",
+  "main": "./build/yayson.cjs",
+  "module": "./build/yayson.mjs",
+  "types": "./build/yayson.d.mts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./build/yayson.d.mts",
+        "default": "./build/yayson.mjs"
+      },
+      "require": {
+        "types": "./build/yayson.d.cts",
+        "default": "./build/yayson.cjs"
+      }
+    },
+    "./legacy": {
+      "import": {
+        "types": "./build/legacy.d.mts",
+        "default": "./build/legacy.mjs"
+      },
+      "require": {
+        "types": "./build/legacy.d.cts",
+        "default": "./build/legacy.cjs"
+      }
+    },
+    "./utils": {
+      "import": {
+        "types": "./build/utils.d.mts",
+        "default": "./build/utils.mjs"
+      },
+      "require": {
+        "types": "./build/utils.d.cts",
+        "default": "./build/utils.cjs"
+      }
+    }
+  },
+  "files": [
+    "build/**/*",
+    "skill/**/*",
+    "README.md",
+    "LICENSE"
+  ],
   "engines": {
-    "node": ">=14",
-    "npm": ">=6"
+    "node": ">=20",
+    "npm": ">=10"
   },
   "scripts": {
-    "test": "mocha",
-    "build": "webpack --config webpack.dist.js",
-    "test-browser": "webpack-dev-server --config webpack.browser.js",
-    "preversion": "npm test && npm run build && git add dist/yayson.js",
+    "test": "tsx node_modules/.bin/mocha",
+    "test:build": "node test/build.test.cjs",
+    "build": "tsdown",
+    "prepublishOnly": "npm run build && npm run test:build",
+    "preversion": "npm test && npm run build && npm run test:build",
     "postversion": "git push --follow-tags origin master",
-    "release": "npm version minor"
+    "release": "npm version minor",
+    "format": "prettier --write src test",
+    "lint": "concurrently --prefix '[{name}]' --prefix-colors '#f73fae,#00c2db,#00db8b' --names 'tsc,eslint,prettier' 'tsc --noEmit' 'eslint .' 'prettier --check .'"
   },
   "repository": {
     "type": "git",
@@ -37,26 +81,26 @@
     "url": "https://github.com/confetti/yayson/issues"
   },
   "homepage": "https://github.com/confetti/yayson",
-  "browserslist": [
-    "defaults",
-    "not IE 11"
-  ],
   "devDependencies": {
-    "@babel/core": "^7.20.12",
-    "@babel/eslint-parser": "^7.19.1",
-    "@babel/preset-env": "^7.20.2",
-    "babel-loader": "^9.1.2",
-    "chai": "^4.3.7",
-    "core-js": "^3.27.2",
-    "eslint": "^8.33.0",
-    "eslint-plugin-mocha": "^10.1.0",
-    "mocha": "^10.2.0",
-    "prettier": "^2.8.3",
-    "sinon": "^15.0.1",
+    "@eslint-community/eslint-plugin-eslint-comments": "4.6.0",
+    "@eslint/js": "^9.35.0",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.5.1",
+    "@types/sinon": "^17.0.4",
+    "@types/sinon-chai": "^4.0.0",
+    "chai": "^4.5.0",
+    "concurrently": "^9.2.1",
+    "eslint": "9.39.1",
+    "eslint-plugin-mocha": "^11.1.0",
+    "globals": "^16.4.0",
+    "mocha": "^11.7.2",
+    "prettier": "3.7.2",
+    "sinon": "^21.0.0",
     "sinon-chai": "^3.7.0",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^5.0.1",
-    "webpack-dev-server": "^4.11.1",
-    "webpack-merge": "^5.8.0"
+    "tsdown": "0.20.0-beta.4",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.44.0",
+    "zod": "4.3.5"
   }
 }