Standardize normalize vs normalise

Author: klis87

packages/normy-react-query/README.md

@@ -10,15 +10,15 @@
 
 <!-- [![Known Vulnerabilities](https://snyk.io/test/github/klis87/normy/badge.svg)](https://snyk.io/test/github/klis87/normy) -->
 
-`react-query` integration with `normy` - automatic normalisation and data updates for data fetching libraries
+`react-query` integration with `normy` - automatic normalization and data updates for data fetching libraries
 
 ## Table of content
 
 - [Introduction](#introduction-arrow_up)
 - [Motivation](#motivation-arrow_up)
 - [Installation](#installation-arrow_up)
 - [Basic usage](#basic-usage-arrow_up)
-- [Disabling of normalisation per query and mutation](#disabling-of-normalisation-per-query-and-mutation-arrow_up)
+- [Disabling of normalization per query and mutation](#disabling-of-normalization-per-query-and-mutation-arrow_up)
 - [Optimistic updates](#optimistic-updates-arrow_up)
 - [Garbage collection](#garbage-collection-arrow_up)
 - [Clearing and unsubscribing from updates](#clearing-and-unsubscribing-from-updates-arrow_up)
@@ -144,15 +144,15 @@ most of the time anymore.
 `createQueryNormalizer` accepts two arguments:
 
 - `queryClient` - this is just a react-query instance you create by `new QueryClient(config)`,
-- `normalizerConfig` - this is `normy` config, which you might need to meet requirements for data normalisation to work - see
+- `normalizerConfig` - this is `normy` config, which you might need to meet requirements for data normalization to work - see
   [explanation](https://github.com/klis87/normy/tree/master/#required-conditions-arrow_up) for more details. Additionally to `normy` config, you can also pass `normalize` option, which is `true` by default - if you pass `false`, nothing will be normalized unless explicitely set (see the next paragraph)
 
-## Disabling of normalisation per query and mutation [:arrow_up:](#table-of-content)
+## Disabling of normalization per query and mutation [:arrow_up:](#table-of-content)
 
 By default all your queries and mutations will be normalized. That means that for each query there will be normalized representation
 of its data and for each mutation its response data will be read and all dependent normalized queries will be updated.
 
-However, it does not always make sense to normalize all data. You might want to disable data normalisation, for example for performance reason for some extreme big queries,
+However, it does not always make sense to normalize all data. You might want to disable data normalization, for example for performance reason for some extreme big queries,
 or just if you do not need it for a given query, for instance if a query data will be never updated.
 
 Anyway, you might want to change this globally by passing `normalize` to `createQueryNormalizer`:
@@ -216,8 +216,8 @@ The above code will immediately update all queries which have object with `id: 1
 a mutation error, data will be reverted to original `rollbackData`.
 
 It will work at the same time as a normal mutation too, so on mutation success, all dependent queries will be updated
-again. If you are sure about the response structure, you might want to disable normalisation for this mutation,
-so that on successful response the normalisation won't be repeted unnecessarily:
+again. If you are sure about the response structure, you might want to disable normalization for this mutation,
+so that on successful response the normalization won't be repeted unnecessarily:
 
 ```jsx
 useMutation({

packages/normy-react-query/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@normy/react-query",
   "version": "0.7.0",
-  "description": "react-query addon for normy - Automatic normalisation and data updates for data fetching libraries",
+  "description": "react-query addon for normy - Automatic normalization and data updates for data fetching libraries",
   "main": "lib/index.js",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",
@@ -11,7 +11,7 @@
   "license": "MIT",
   "typings": "types/index.d.ts",
   "keywords": [
-    "normalisation",
+    "normalization",
     "react-query"
   ],
   "homepage": "https://github.com/klis87/normy",

packages/normy/README.md

@@ -10,15 +10,15 @@
 
 <!-- [![Known Vulnerabilities](https://snyk.io/test/github/klis87/normy/badge.svg)](https://snyk.io/test/github/klis87/normy) -->
 
-Automatic normalisation and data updates for data fetching libraries
+Automatic normalization and data updates for data fetching libraries
 
 ## Table of content
 
 - [Introduction](#introduction-arrow_up)
 - [Motivation](#motivation-arrow_up)
 - [Installation](#installation-arrow_up)
 - [Required conditions](#required-conditions-arrow_up)
-- [Normalisation of arrays](#normalisation-of-arrays-arrow_up)
+- [Normalization of arrays](#normalization-of-arrays-arrow_up)
 - [Debugging](#debugging-arrow_up)
 - [Performance](#performance-arrow_up)
 - [Integrations](#examples-arrow_up)
@@ -158,22 +158,22 @@ in the future a guide will be created.
 
 ## Required conditions [:arrow_up:](#table-of-content)
 
-In order to make automatic normalisation work, the following conditions must be met:
+In order to make automatic normalization work, the following conditions must be met:
 
 1. you must have a standardized way to identify your objects, usually this is done by key `id`
 2. ids must be unique across the whole app, not only across object types, if not, you will need to append something to them,
    the same has to be done in GraphQL world, usually adding `_typename`
 3. objects with the same ids should have a consistent structure, if an object like book in one
    query has `title` key, it should be `title` in others, not `name` out of a sudden
 
-There is a function which can be passed to `createQueryNormalizer` to meet those requirements, namely `getNormalisationObjectKey`.
+There is a function which can be passed to `createQueryNormalizer` to meet those requirements, namely `getNormalizationObjectKey`.
 
-`getNormalisationObjectKey` can help you with 1st point, if for instance you identify
-objects differently, like by `_id` key, then you can pass `getNormalisationObjectKey: obj => obj._id`.
+`getNormalizationObjectKey` can help you with 1st point, if for instance you identify
+objects differently, like by `_id` key, then you can pass `getNormalizationObjectKey: obj => obj._id`.
 
-`getNormalisationObjectKey` also allows you to pass the 2nd requirement. For example, if your ids
+`getNormalizationObjectKey` also allows you to pass the 2nd requirement. For example, if your ids
 are unique, but not across the whole app, but within object types, you could use
-`getNormalisationObjectKey: obj => obj.id && obj.type ? obj.id + obj.type : undefined` or something similar.
+`getNormalizationObjectKey: obj => obj.id && obj.type ? obj.id + obj.type : undefined` or something similar.
 If that is not possible, then you could just compute a suffix yourself, for example:
 
 ```js
@@ -190,15 +190,15 @@ const getType = obj => {
 };
 
 createQueryNormalizer(queryClient, {
-  getNormalisationObjectKey: obj =>
+  getNormalizationObjectKey: obj =>
     obj.id && getType(obj) && obj.id + getType(obj),
 });
 ```
 
 Point 3 should always be met, if not, your really should ask your backend developers
 to keep things standardized and consistent. As a last resort, you can amend responses on your side.
 
-## Normalisation of arrays [:arrow_up:](#table-of-content)
+## Normalization of arrays [:arrow_up:](#table-of-content)
 
 Unfortunately it does not mean you will never need to update data manually anymore. Some updates still need
 to be done manually like usually, namely adding and removing items from array. Why? Imagine a `REMOVE_BOOK`
@@ -235,11 +235,11 @@ However, you have several flexible ways to improve performance:
 1. You can normalize only queries which have data updates, and only mutations which should update data - that's it,
    you can have only part of your data normalized. Check an integration documentation how to do it.
 2. Like `1.`, but for queries and mutations with extremely big data.
-3. You can use `getNormalisationObjectKey` function to set globally which objects should be actually normalized. For example:
+3. You can use `getNormalizationObjectKey` function to set globally which objects should be actually normalized. For example:
 
 ```js
 createQueryNormalizer(queryClient, {
-  getNormalisationObjectKey: obj => (obj.normalizable ? obj.id : undefined),
+  getNormalizationObjectKey: obj => (obj.normalizable ? obj.id : undefined),
 });
 ```
 

packages/normy/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@normy/core",
   "version": "0.6.0",
-  "description": "Automatic normalisation and data updates for data fetching libraries",
+  "description": "Automatic normalization and data updates for data fetching libraries",
   "main": "lib/index.js",
   "module": "es/index.js",
   "jsnext:main": "es/index.js",
@@ -11,7 +11,7 @@
   "license": "MIT",
   "typings": "types/index.d.ts",
   "keywords": [
-    "normalisation",
+    "normalization",
     "react-query"
   ],
   "homepage": "https://github.com/klis87/normy",

packages/normy/src/create-normalizer.spec.ts

@@ -218,9 +218,9 @@ describe('createNormalizer', () => {
       });
     });
 
-    it('allows to override normalisation key', () => {
+    it('allows to override normalization key', () => {
       const normalizer = createNormalizer({
-        getNormalisationObjectKey: obj => obj._id as string,
+        getNormalizationObjectKey: obj => obj._id as string,
       });
       normalizer.setQuery('query', {
         _id: '1',
@@ -243,9 +243,9 @@ describe('createNormalizer', () => {
       });
     });
 
-    it('allows to disable normalisation per object', () => {
+    it('allows to disable normalization per object', () => {
       const normalizer = createNormalizer({
-        getNormalisationObjectKey: obj => obj._id as string,
+        getNormalizationObjectKey: obj => obj._id as string,
       });
       normalizer.setQuery('query', {
         _id: '1',

packages/normy/src/default-config.ts

@@ -1,6 +1,6 @@
 import { NormalizerConfig } from './types';
 
 export const defaultConfig: Required<NormalizerConfig> = {
-  getNormalisationObjectKey: obj => obj.id as string | undefined,
+  getNormalizationObjectKey: obj => obj.id as string | undefined,
   devLogging: false,
 };

packages/normy/src/normalize.spec.ts

@@ -305,15 +305,15 @@ describe('normalize', () => {
     ]);
   });
 
-  it('should support configurable normalisation options', () => {
+  it('should support configurable normalization options', () => {
     expect(
       normalize(
         [
           { id: '1', key: 'a' },
           { _id: '2', key: 'b' },
         ],
         {
-          getNormalisationObjectKey: obj =>
+          getNormalizationObjectKey: obj =>
             obj._id && obj.key
               ? `${obj._id as string}${obj.key as string}`
               : undefined,

packages/normy/src/normalize.ts

@@ -20,7 +20,7 @@ const stipFromDeps = (
   }
 
   if (data !== null && typeof data === 'object') {
-    const objectKey = config.getNormalisationObjectKey(data);
+    const objectKey = config.getNormalizationObjectKey(data);
 
     if (objectKey && root) {
       return `@@${objectKey}`;
@@ -58,7 +58,7 @@ export const getDependencies = (
   }
 
   if (data !== null && typeof data === 'object') {
-    if (config.getNormalisationObjectKey(data)) {
+    if (config.getNormalizationObjectKey(data)) {
       usedKeys[path] = Object.keys(data);
     }
 
@@ -68,7 +68,7 @@ export const getDependencies = (
           ...prev,
           ...getDependencies(v, config, usedKeys, `${path}.${k}`)[0],
         ],
-        config.getNormalisationObjectKey(data) ? [data] : [],
+        config.getNormalizationObjectKey(data) ? [data] : [],
       ),
       usedKeys,
     ];
@@ -86,7 +86,7 @@ export const normalize = (
   return [
     stipFromDeps(data, config, true),
     dependencies.reduce((prev, v) => {
-      const key = config.getNormalisationObjectKey(v) as string;
+      const key = config.getNormalizationObjectKey(v) as string;
 
       prev[`@@${key}`] = prev[`@@${key}`]
         ? mergeData(prev[`@@${key}`], stipFromDeps(v, config, false))

packages/normy/src/types.ts

@@ -19,7 +19,7 @@ export type Data =
   | DataObject[];
 
 export type NormalizerConfig = {
-  getNormalisationObjectKey?: (obj: DataObject) => string | undefined;
+  getNormalizationObjectKey?: (obj: DataObject) => string | undefined;
   devLogging?: boolean;
 };