@pinia-orm/normalizr-edge 1.7.1-28257628.bbb8bab

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-present Gregor Becker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+[![Pinia ORM banner](./.github/assets/banner.png)](https://github.com/storm-tail/pinia-orm)
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![Github Actions CI][github-actions-ci-src]][github-actions-ci-href]
+[![Coverage][code-coverage-src]][code-coverage-href]
+[![License][license-src]][license-href]
+
+# Welcome to pinia-orm
+
+> Intuitive, type safe and flexible ORM for Pinia based on [Vuex ORM Next](https://github.com/vuex-orm/vuex-orm-next)
+
+- [✨  Release Notes](https://pinia-orm.codedredd.de/changelog)
+- [📖  Documentation](https://pinia-orm.codedredd.de)
+- [👾  Playground](https://pinia-orm-play.codedredd.de)
+
+## Migration from vuex-orm
+
+You want to migrate from vuex to pinia and with it vuex-orm to pinia-orm but you don't know yet?
+Well maybe this table will help you to decide. This comparison is just about facts and current state.
+
+| Features                                                               | pinia-orm@v1.4.0                                           | @vuex-orm/core@0.36.4                                             | @vuex-orm/core@1.0.0-draft.16                                             |
+|------------------------------------------------------------------------|------------------------------------------------------------| ----------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| Bundle Size (Min + GZIP)                                               | [9.9 KB](https://bundlephobia.com/package/pinia-orm@1.4.0) | [16.7 KB](https://bundlephobia.com/package/@vuex-orm/core@0.36.4) | [12.6 KB](https://bundlephobia.com/package/@vuex-orm/core@1.0.0-draft.16) |
+| Relations (hasMany, belongsTo, morphOne, hasManyBy, hasOne, morphTo)   | ✅                                                          | ✅                                                                | ✅                                                                        |
+| Relations (morphMany, belongsToMany, hasManyThrough)                   | ✅                                                          | ✅                                                                | ❌                                                                        |
+| Relations (morphToMany, morphedByMany)                                 | ❌                                                          | ✅                                                                | ❌                                                                        |
+| Mutators                                                               | ✅                                                          | ✅                                                                | ❌                                                                        |
+| Casts                                                                  | ✅                                                          | ❌                                                                | ❌                                                                        |
+| Decorators                                                             | ✅                                                          | ❌                                                                | ✅                                                                        |
+| Single Table Inheritance                                               | ✅                                                          | ✅                                                                | ❌                                                                        |
+| Lifecycle Hooks                                                        | ✅                                                          | ✅                                                                | ❌                                                                        |
+| Aggregates                                                             | ✅                                                          | ✅                                                                | ❌                                                                        |
+| Query (orHas, doesntHave, orDoesntHave, whereHas, orWhereHas, groupBy) | ✅                                                          | ❌                                                                | ❌                                                                        |
+| Collection Helpers                                                     | ✅                                                          | (✅) can use pinia-orm helpers too                                | (✅) can use pinia-orm helpers too                                        |
+| Hidden Fields                                                          | ✅                                                          | ❌                                                                | ❌                                                                        |
+| Metadata field                                                         | ✅                                                          | ❌                                                                | ❌                                                                        |
+| Caching of queries with gc                                             | ✅                                                          | (✅) with plugin                                                  | ❌                                                                        |
+
+If you decide to migrate then there are some breaking changes. A guide how to migrate will be written.
+Small overview:
+
+- Fields are by default `null`
+- Renamed some functions aligning more with laravel naming
+- Code is based on `vuex-orm-next` and not on `vuex-orm` !
+
+## Help me keep working on this project 💚
+
+- [Become a Sponsor on GitHub](https://github.com/sponsors/codedredd)
+- [One-time donation via PayPal](https://paypal.me/dredd1984)
+
+<p align="center">
+  <a href="https://pinia-orm.codedredd.de/sponsorkit/sponsors.png">
+    <img src='https://pinia-orm.codedredd.de/sponsorkit/sponsors.svg'/>
+  </a>
+</p>
+
+---
+
+## 💻 Development
+
+- Clone this repository
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable` (use `npm i -g corepack` for Node.js < 16.10)
+- Install dependencies using `pnpm install`
+- Build normalizr package: `pnpm build`
+- Run interactive tests using `cd packages/pinia-orm && pnpm test:ui`
+
+## Credits
+
+- [Kia King Ishii](https://github.com/kiaking)
+- [Cuebit](https://github.com/cuebit)
+- [Posva](https://github.com/posva)
+
+## Related projects
+
+- [Vuex ORM](https://github.com/vuex-orm/vuex-orm)
+- [Vuex ORM Next](https://github.com/vuex-orm/vuex-orm-next)
+
+## License
+
+Made with ❤️
+
+Published under [MIT License](./LICENCE).
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/pinia-orm/latest.svg
+[code-coverage-src]: https://img.shields.io/codecov/c/github/CodeDredd/pinia-orm?logo=Codecov&logoColor=white&token=BYLAJJOOLS
+[code-coverage-href]: https://app.codecov.io/gh/CodeDredd/pinia-orm
+[npm-version-href]: https://npmjs.com/package/pinia-orm
+[npm-downloads-src]: https://img.shields.io/npm/dm/pinia-orm.svg
+[npm-downloads-href]: https://npmjs.com/package/pinia-orm
+[github-actions-ci-src]: https://github.com/codedredd/pinia-orm/actions/workflows/ci.yml/badge.svg
+[github-actions-ci-href]: https://github.com/codedredd/pinia-orm/actions?query=workflow%3Aci
+[license-src]: https://img.shields.io/npm/l/pinia-orm.svg
+[license-href]: https://npmjs.com/package/pinia-orm

package/dist/index.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+class EntitySchema {
+  constructor(key, definition = {}, options = {}) {
+    if (!key || typeof key !== "string") {
+      throw new Error(`Expected a string key for Entity, but found ${key}.`);
+    }
+    const {
+      idAttribute = "id",
+      mergeStrategy = (entityA, entityB) => {
+        return { ...entityA, ...entityB };
+      },
+      processStrategy = (input) => ({ ...input })
+    } = options;
+    this._key = key;
+    this._getId = idAttribute;
+    this._mergeStrategy = mergeStrategy;
+    this._processStrategy = processStrategy;
+    this.define(definition);
+  }
+  get key() {
+    return this._key;
+  }
+  define(definition) {
+    this.schema = Object.keys(definition).reduce((entitySchema, key) => {
+      const schema = definition[key];
+      return { ...entitySchema, [key]: schema };
+    }, this.schema || {});
+  }
+  getId(input, parent, key) {
+    return this._getId(input, parent, key);
+  }
+  merge(entityA, entityB) {
+    return this._mergeStrategy(entityA, entityB);
+  }
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    const id = this.getId(input, parent, key);
+    const entityType = this.key;
+    if (!(entityType in visitedEntities)) {
+      visitedEntities[entityType] = {};
+    }
+    if (!(id in visitedEntities[entityType])) {
+      visitedEntities[entityType][id] = [];
+    }
+    if (visitedEntities[entityType][id].includes(input)) {
+      return id;
+    }
+    visitedEntities[entityType][id].push(input);
+    const processedEntity = this._processStrategy(input, parent, key);
+    Object.keys(this.schema).forEach((key2) => {
+      if (processedEntity.hasOwnProperty(key2) && typeof processedEntity[key2] === "object") {
+        const schema = this.schema[key2];
+        const resolvedSchema = typeof schema === "function" ? schema(input) : schema;
+        processedEntity[key2] = visit(
+          processedEntity[key2],
+          processedEntity,
+          key2,
+          resolvedSchema,
+          addEntity,
+          visitedEntities
+        );
+      }
+    });
+    addEntity(this, processedEntity, input, parent, key);
+    return id;
+  }
+}
+
+class PolymorphicSchema {
+  constructor(definition, schemaAttribute) {
+    if (schemaAttribute) {
+      this._schemaAttribute = typeof schemaAttribute === "string" ? (input) => input[schemaAttribute] : schemaAttribute;
+    }
+    this.define(definition);
+  }
+  get isSingleSchema() {
+    return !this._schemaAttribute;
+  }
+  define(definition) {
+    this.schema = definition;
+  }
+  getSchemaAttribute(input, parent, key) {
+    return !this.isSingleSchema && this._schemaAttribute(input, parent, key);
+  }
+  inferSchema(input, parent, key) {
+    if (this.isSingleSchema) {
+      return this.schema;
+    }
+    const attr = this.getSchemaAttribute(input, parent, key);
+    return this.schema[attr];
+  }
+  normalizeValue(value, parent, key, visit, addEntity, visitedEntities) {
+    const schema = this.inferSchema(value, parent, key);
+    if (!schema) {
+      return value;
+    }
+    const normalizedValue = visit(value, parent, key, schema, addEntity, visitedEntities);
+    return this.isSingleSchema || normalizedValue === void 0 || normalizedValue === null ? normalizedValue : { id: normalizedValue, schema: this.getSchemaAttribute(value, parent, key) };
+  }
+}
+
+class UnionSchema extends PolymorphicSchema {
+  constructor(definition, schemaAttribute) {
+    if (!schemaAttribute) {
+      throw new Error('Expected option "schemaAttribute" not found on UnionSchema.');
+    }
+    super(definition, schemaAttribute);
+  }
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    return this.normalizeValue(input, parent, key, visit, addEntity, visitedEntities);
+  }
+}
+
+const validateSchema = (definition) => {
+  if (Array.isArray(definition) && definition.length > 1) {
+    throw new Error(`Expected schema definition to be a single schema, but found ${definition.length}.`);
+  }
+  return definition[0];
+};
+const getValues = (input) => Array.isArray(input) ? input : Object.keys(input).map((key) => input[key]);
+const normalize$2 = (schema, input, parent, key, visit, addEntity, visitedEntities) => {
+  return getValues(input).map((value) => visit(value, parent, key, validateSchema(schema), addEntity, visitedEntities));
+};
+class ArraySchema extends PolymorphicSchema {
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    return getValues(input).map((value) => this.normalizeValue(value, parent, key, visit, addEntity, visitedEntities)).filter((value) => value !== void 0 && value !== null);
+  }
+}
+
+const normalize$1 = (schema, input, parent, key, visit, addEntity, visitedEntities) => {
+  const object = { ...input };
+  Object.keys(schema).forEach((key2) => {
+    const localSchema = schema[key2];
+    const resolvedLocalSchema = typeof localSchema === "function" ? localSchema(input) : localSchema;
+    const value = visit(input[key2], input, key2, resolvedLocalSchema, addEntity, visitedEntities);
+    if (value === void 0 || value === null) {
+      delete object[key2];
+    } else {
+      object[key2] = value;
+    }
+  });
+  return object;
+};
+
+const visit = (value, parent, key, schema2, addEntity, visitedEntities) => {
+  if (typeof value !== "object" || !value) {
+    return value;
+  }
+  if (typeof schema2 === "object" && (!schema2.normalize || typeof schema2.normalize !== "function")) {
+    const method = Array.isArray(schema2) ? normalize$2 : normalize$1;
+    return method(schema2, value, parent, key, visit, addEntity, visitedEntities);
+  }
+  return schema2.normalize(value, parent, key, visit, addEntity, visitedEntities);
+};
+const addEntities = (entities) => (schema2, processedEntity, value, parent, key) => {
+  const schemaKey = schema2.key;
+  const id = schema2.getId(value, parent, key);
+  if (!(schemaKey in entities)) {
+    entities[schemaKey] = {};
+  }
+  entities[schemaKey][id] = entities[schemaKey][id] ? schema2.merge(entities[schemaKey][id], processedEntity) : processedEntity;
+};
+const schema = {
+  Array: ArraySchema,
+  Entity: EntitySchema,
+  Union: UnionSchema
+};
+const normalize = (input, schema2) => {
+  if (!input || typeof input !== "object") {
+    throw new Error(
+      `Unexpected input given to normalize. Expected type to be "object", found "${input === null ? "null" : typeof input}".`
+    );
+  }
+  const entities = {};
+  const addEntity = addEntities(entities);
+  const visitedEntities = {};
+  const result = visit(input, input, null, schema2, addEntity, visitedEntities);
+  return { entities, result };
+};
+
+exports.normalize = normalize;
+exports.schema = schema;

package/dist/index.mjs

@@ -0,0 +1,179 @@
+class EntitySchema {
+  constructor(key, definition = {}, options = {}) {
+    if (!key || typeof key !== "string") {
+      throw new Error(`Expected a string key for Entity, but found ${key}.`);
+    }
+    const {
+      idAttribute = "id",
+      mergeStrategy = (entityA, entityB) => {
+        return { ...entityA, ...entityB };
+      },
+      processStrategy = (input) => ({ ...input })
+    } = options;
+    this._key = key;
+    this._getId = idAttribute;
+    this._mergeStrategy = mergeStrategy;
+    this._processStrategy = processStrategy;
+    this.define(definition);
+  }
+  get key() {
+    return this._key;
+  }
+  define(definition) {
+    this.schema = Object.keys(definition).reduce((entitySchema, key) => {
+      const schema = definition[key];
+      return { ...entitySchema, [key]: schema };
+    }, this.schema || {});
+  }
+  getId(input, parent, key) {
+    return this._getId(input, parent, key);
+  }
+  merge(entityA, entityB) {
+    return this._mergeStrategy(entityA, entityB);
+  }
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    const id = this.getId(input, parent, key);
+    const entityType = this.key;
+    if (!(entityType in visitedEntities)) {
+      visitedEntities[entityType] = {};
+    }
+    if (!(id in visitedEntities[entityType])) {
+      visitedEntities[entityType][id] = [];
+    }
+    if (visitedEntities[entityType][id].includes(input)) {
+      return id;
+    }
+    visitedEntities[entityType][id].push(input);
+    const processedEntity = this._processStrategy(input, parent, key);
+    Object.keys(this.schema).forEach((key2) => {
+      if (processedEntity.hasOwnProperty(key2) && typeof processedEntity[key2] === "object") {
+        const schema = this.schema[key2];
+        const resolvedSchema = typeof schema === "function" ? schema(input) : schema;
+        processedEntity[key2] = visit(
+          processedEntity[key2],
+          processedEntity,
+          key2,
+          resolvedSchema,
+          addEntity,
+          visitedEntities
+        );
+      }
+    });
+    addEntity(this, processedEntity, input, parent, key);
+    return id;
+  }
+}
+
+class PolymorphicSchema {
+  constructor(definition, schemaAttribute) {
+    if (schemaAttribute) {
+      this._schemaAttribute = typeof schemaAttribute === "string" ? (input) => input[schemaAttribute] : schemaAttribute;
+    }
+    this.define(definition);
+  }
+  get isSingleSchema() {
+    return !this._schemaAttribute;
+  }
+  define(definition) {
+    this.schema = definition;
+  }
+  getSchemaAttribute(input, parent, key) {
+    return !this.isSingleSchema && this._schemaAttribute(input, parent, key);
+  }
+  inferSchema(input, parent, key) {
+    if (this.isSingleSchema) {
+      return this.schema;
+    }
+    const attr = this.getSchemaAttribute(input, parent, key);
+    return this.schema[attr];
+  }
+  normalizeValue(value, parent, key, visit, addEntity, visitedEntities) {
+    const schema = this.inferSchema(value, parent, key);
+    if (!schema) {
+      return value;
+    }
+    const normalizedValue = visit(value, parent, key, schema, addEntity, visitedEntities);
+    return this.isSingleSchema || normalizedValue === void 0 || normalizedValue === null ? normalizedValue : { id: normalizedValue, schema: this.getSchemaAttribute(value, parent, key) };
+  }
+}
+
+class UnionSchema extends PolymorphicSchema {
+  constructor(definition, schemaAttribute) {
+    if (!schemaAttribute) {
+      throw new Error('Expected option "schemaAttribute" not found on UnionSchema.');
+    }
+    super(definition, schemaAttribute);
+  }
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    return this.normalizeValue(input, parent, key, visit, addEntity, visitedEntities);
+  }
+}
+
+const validateSchema = (definition) => {
+  if (Array.isArray(definition) && definition.length > 1) {
+    throw new Error(`Expected schema definition to be a single schema, but found ${definition.length}.`);
+  }
+  return definition[0];
+};
+const getValues = (input) => Array.isArray(input) ? input : Object.keys(input).map((key) => input[key]);
+const normalize$2 = (schema, input, parent, key, visit, addEntity, visitedEntities) => {
+  return getValues(input).map((value) => visit(value, parent, key, validateSchema(schema), addEntity, visitedEntities));
+};
+class ArraySchema extends PolymorphicSchema {
+  normalize(input, parent, key, visit, addEntity, visitedEntities) {
+    return getValues(input).map((value) => this.normalizeValue(value, parent, key, visit, addEntity, visitedEntities)).filter((value) => value !== void 0 && value !== null);
+  }
+}
+
+const normalize$1 = (schema, input, parent, key, visit, addEntity, visitedEntities) => {
+  const object = { ...input };
+  Object.keys(schema).forEach((key2) => {
+    const localSchema = schema[key2];
+    const resolvedLocalSchema = typeof localSchema === "function" ? localSchema(input) : localSchema;
+    const value = visit(input[key2], input, key2, resolvedLocalSchema, addEntity, visitedEntities);
+    if (value === void 0 || value === null) {
+      delete object[key2];
+    } else {
+      object[key2] = value;
+    }
+  });
+  return object;
+};
+
+const visit = (value, parent, key, schema2, addEntity, visitedEntities) => {
+  if (typeof value !== "object" || !value) {
+    return value;
+  }
+  if (typeof schema2 === "object" && (!schema2.normalize || typeof schema2.normalize !== "function")) {
+    const method = Array.isArray(schema2) ? normalize$2 : normalize$1;
+    return method(schema2, value, parent, key, visit, addEntity, visitedEntities);
+  }
+  return schema2.normalize(value, parent, key, visit, addEntity, visitedEntities);
+};
+const addEntities = (entities) => (schema2, processedEntity, value, parent, key) => {
+  const schemaKey = schema2.key;
+  const id = schema2.getId(value, parent, key);
+  if (!(schemaKey in entities)) {
+    entities[schemaKey] = {};
+  }
+  entities[schemaKey][id] = entities[schemaKey][id] ? schema2.merge(entities[schemaKey][id], processedEntity) : processedEntity;
+};
+const schema = {
+  Array: ArraySchema,
+  Entity: EntitySchema,
+  Union: UnionSchema
+};
+const normalize = (input, schema2) => {
+  if (!input || typeof input !== "object") {
+    throw new Error(
+      `Unexpected input given to normalize. Expected type to be "object", found "${input === null ? "null" : typeof input}".`
+    );
+  }
+  const entities = {};
+  const addEntity = addEntities(entities);
+  const visitedEntities = {};
+  const result = visit(input, input, null, schema2, addEntity, visitedEntities);
+  return { entities, result };
+};
+
+export { normalize, schema };

package/index.d.ts

@@ -0,0 +1,63 @@
+declare namespace schema {
+  export type StrategyFunction<T> = (value: any, parent: any, key: string) => T;
+  export type SchemaFunction = (value: any, parent: any, key: string) => string;
+  export type MergeFunction = (entityA: any, entityB: any) => any;
+
+  export class Array<T = any> {
+    constructor(definition: Schema<T>, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+
+  export interface EntityOptions<T = any> {
+    idAttribute?: string | SchemaFunction
+    mergeStrategy?: MergeFunction
+    processStrategy?: StrategyFunction<T>
+  }
+
+  export class Entity<T = any> {
+    constructor(key: string | symbol, definition?: Schema, options?: EntityOptions<T>)
+    define(definition: Schema): void
+    key: string
+    getId: SchemaFunction
+    _processStrategy: StrategyFunction<T>
+  }
+
+  export class Object<T = any> {
+    constructor(definition: SchemaObject<T>)
+    define(definition: Schema): void
+  }
+
+  export class Union<T = any> {
+    constructor(definition: Schema<T>, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+
+  export class Values<T = any> {
+    constructor(definition: Schema<T>, schemaAttribute?: string | SchemaFunction)
+    define(definition: Schema): void
+  }
+}
+
+export type Schema<T = any> =
+  | schema.Entity<T>
+  | schema.Object<T>
+  | schema.Union<T>
+  | schema.Values<T>
+  | SchemaObject<T>
+  | SchemaArray<T>;
+
+export type SchemaValueFunction<T> = (t: T) => Schema<T>;
+export type SchemaValue<T> = Schema<T> | SchemaValueFunction<T>;
+
+export interface SchemaObject<T> {
+  [key: string]: SchemaValue<T>
+}
+
+export interface SchemaArray<T> extends Array<Schema<T>> {}
+
+export type NormalizedSchema<E, R> = { entities: E, result: R };
+
+export function normalize<T = any, E = { [key:string]: { [key:string]: T } | undefined}, R = any>(
+  data: any,
+  schema: Schema<T>
+): NormalizedSchema<E, R>;

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@pinia-orm/normalizr-edge",
+  "version": "1.7.1-28257628.bbb8bab",
+  "description": "Normalizes JSON according to schema for Redux and Flux applications",
+  "bugs": {
+    "url": "https://github.com/CodeDredd/pinia-orm/issues"
+  },
+  "homepage": "https://github.com/CodeDredd/pinia-orm",
+  "repository": {
+    "url": "https://github.com/CodeDredd/pinia-orm.git",
+    "type": "git"
+  },
+  "keywords": [
+    "flux",
+    "redux",
+    "normalize",
+    "api",
+    "json"
+  ],
+  "files": [
+    "dist/",
+    "index.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "funding": "https://github.com/sponsors/codedredd",
+  "jsdelivr": "dist/index.mjs",
+  "unpkg": "dist/index.mjs",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    },
+    "./*": "./*"
+  },
+  "sideEffects": false,
+  "author": "Paul Armstrong",
+  "contributors": [
+    "Dan Abramov",
+    "Gregor Becker"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@nuxtjs/eslint-config-typescript": "^12.1.0",
+    "@size-limit/preset-small-lib": "^9.0.0",
+    "eslint": "^8.49.0",
+    "immutable": "^4.3.4",
+    "size-limit": "^9.0.0",
+    "typescript": "^5.2.2",
+    "unbuild": "^2.0.0"
+  },
+  "size-limit": [
+    {
+      "path": "dist/index.mjs",
+      "limit": "2 kB"
+    }
+  ],
+  "_name": "@pinia-orm/normalizr",
+  "scripts": {
+    "build": "unbuild",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s --commit-path . -l @pinia-orm/normalizr -r 1",
+    "size": "size-limit",
+    "flow": "flow",
+    "flow:ci": "flow check",
+    "lint": "eslint . --ext .js",
+    "lint:fix": "eslint . --fix --ext .js"
+  }
+}