@sparted/shared-library 1.0.29 → 1.1.0-rc0

package/{cdn → dist/cdn}/utils/get-cdn-from-s3-url.util.d.ts

@@ -1,5 +1,5 @@
 import type { GetCdnFromS3Url, GetCdnUrl } from '../types';
-declare type FactoryConfig = {
+type FactoryConfig = {
     getCdnUrl: GetCdnUrl;
 };
 export declare function getCdnFromS3UrlFactory(config: FactoryConfig): GetCdnFromS3Url;

package/{cdn → dist/cdn}/utils/get-cdn-url.util.d.ts

@@ -1,5 +1,5 @@
 import type { GetCdnUrl, InstanceMapper, TransformationQueries } from '../types';
-declare type FactoryConfig = {
+type FactoryConfig = {
     domain: `https://${string}`;
     instanceMapper: InstanceMapper;
     transformationQueries: TransformationQueries;

package/{fp → dist/fp}/run-while.d.ts

@@ -1,4 +1,4 @@
-export declare type RunWhileConfig<T> = {
+export type RunWhileConfig<T> = {
     /**
      * Return a boolean to keep running the callback or not.
      */
@@ -17,7 +17,7 @@ export declare type RunWhileConfig<T> = {
      */
     initialValue: T;
 };
-export declare type RunWhileFn = <T>(config: RunWhileConfig<T>) => {
+export type RunWhileFn = <T>(config: RunWhileConfig<T>) => {
     /**
      * The callback last result.
      */

package/{http → dist/http}/encode-search-object.d.ts

@@ -1,5 +1,5 @@
 import { SearchObject } from '../types';
-export declare type EncodingConfig = {
+export type EncodingConfig = {
     keyValueDelimiter: string;
     pairDelimiter: string;
 };

package/{http → dist/http}/fetch-with-timeout.d.ts

@@ -1,4 +1,4 @@
-export declare type RequestInitWithTimeout = RequestInit & {
+export type RequestInitWithTimeout = RequestInit & {
     timeout?: number;
 };
 /**

package/{index.d.ts → dist/index.d.ts}

@@ -12,4 +12,3 @@ export * from './predicates';
 export * from './promise';
 export * from './string';
 export * from './types';
-export * from './color';

package/{index.js → dist/index.js}

@@ -37,7 +37,6 @@ var executeWithDelay = require('./promise/execute-with-delay.js');
 var delay = require('./promise/delay.js');
 var replaceInTemplate = require('./string/replace-in-template.js');
 var isStringLengthWithinRange = require('./string/is-string-length-within-range.js');
-var getContrastColor = require('./color/get-contrast-color.js');
 
 
 
@@ -83,5 +82,4 @@ exports.executeWithDelay = executeWithDelay.executeWithDelay;
 exports.delay = delay.delay;
 exports.replaceInTemplate = replaceInTemplate.replaceInTemplate;
 exports.isStringLengthWithinRange = isStringLengthWithinRange.isStringLengthWithinRange;
-exports.getContrastColor = getContrastColor.getContrastColor;
 //# sourceMappingURL=index.js.map

package/{index.js.map → dist/index.js.map}

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/{linked-list → dist/linked-list}/linked-list-utils.d.ts

@@ -1,21 +1,21 @@
 import { LinkedListFormat, LinkedListItem, SimpleLinkedList } from './type';
-export declare type WalkConfig<T extends LinkedListItem, Result> = {
+export type WalkConfig<T extends LinkedListItem, Result> = {
     startId: string | null;
     items: Record<string, T>;
     initValue: Result;
 };
-declare type WalkCallbackResult<R> = {
+type WalkCallbackResult<R> = {
     result: R;
     control?: {
         stop?: boolean;
     };
 };
-export declare type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;
+export type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;
 export declare const walkListItemRecord: <T extends LinkedListItem, Result>(callback: WalkCallback<T, Result>, config: WalkConfig<T, Result>) => Result;
 export declare const findPreviousId: <T extends LinkedListItem>(id: string | null, list: SimpleLinkedList<T>) => string | null;
 export declare const assertItemCompatibility: <T extends LinkedListItem>(item: T, format: LinkedListFormat | null) => void;
 export declare const assertPresence: (id: string | null | undefined, items: Record<string, unknown>) => void;
-declare type PositionAssertionConfig = {
+type PositionAssertionConfig = {
     previousId: string | null;
     list: SimpleLinkedList<LinkedListItem>;
 };

package/{linked-list → dist/linked-list}/type.d.ts

@@ -1,23 +1,23 @@
-export declare type LinkedListItem = {
+export type LinkedListItem = {
     id: string;
     nextId: string | null;
     previousId?: string | null;
 };
-export declare type SimpleLinkedList<T extends LinkedListItem> = {
+export type SimpleLinkedList<T extends LinkedListItem> = {
     headId: string | null;
     items: {
         [id: string]: T;
     };
 };
-export declare type ReduceCallback<Item, Result> = (accumulator: Result, current: Item) => Result;
-export declare type ItemPredicate<Item> = (item: Item) => boolean;
-export declare type LinkedListFormat = 'double' | 'single';
-export declare type ManipulationConfig<T extends LinkedListItem> = {
+export type ReduceCallback<Item, Result> = (accumulator: Result, current: Item) => Result;
+export type ItemPredicate<Item> = (item: Item) => boolean;
+export type LinkedListFormat = 'double' | 'single';
+export type ManipulationConfig<T extends LinkedListItem> = {
     format: LinkedListFormat | null;
     list: SimpleLinkedList<T>;
     factory: (list: SimpleLinkedList<T>) => LinkedList<T>;
 };
-export declare type LinkedList<T extends LinkedListItem> = {
+export type LinkedList<T extends LinkedListItem> = {
     readonly head: T | null;
     readonly items: {
         [id: string]: T;

package/{math → dist/math}/interpolate.d.ts

@@ -1,2 +1,2 @@
-export declare type RangeArray = [number, number];
+export type RangeArray = [number, number];
 export declare const interpolate: (num: number, inputRange: RangeArray, outputRange: RangeArray) => number;

package/{math → dist/math}/number-range.d.ts

@@ -1,4 +1,4 @@
-export declare type NumberRange = {
+export type NumberRange = {
     min: number;
     max: number;
 };

package/dist/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@sparted/shared-library",
+  "version": "1.0.28",
+  "repository": "git@github.com:Sparted/shared-library.git",
+  "author": {
+    "name": "Sparted",
+    "email": "developer@sparted.com",
+    "url": "https://www.sparted.com"
+  },
+  "license": "MIT",
+  "sideEffets": false,
+  "main": "cjs/index.js",
+  "files": [
+    "**/*",
+    "**/**"
+  ],
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "clean": "rm -rf ./dist",
+    "build": "yarn clean && rollup --config rollup.config.ts --configPlugin typescript2 && cp package.json ./dist/package.json",
+    "build-and-publish": "yarn test && yarn build && (cd ./dist && NPM_CONFIG_REGISTRY=undefined npm publish)"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.0.0",
+    "@types/jest": "^29.0.3",
+    "@types/ungap__structured-clone": "^0.3.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "glob": "^8.0.3",
+    "jest": "^29.6.1",
+    "jest-environment-jsdom": "^29.0.3",
+    "jest-extended": "^3.1.0",
+    "jest-fetch-mock": "^3.0.3",
+    "prettier": "2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-typescript2": "^0.34.0",
+    "ts-jest": "^29.0.2",
+    "tslib": "^2.4.0",
+    "typescript": "^4.8.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ],
+    "rootDir": ".",
+    "testRegex": [
+      ".*\\.test\\.ts$"
+    ],
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    }
+  },
+  "dependencies": {
+    "@ungap/structured-clone": "^1.2.0"
+  }
+}

package/{promise → dist/promise}/execute-or-resolve-default.d.ts

@@ -1,4 +1,4 @@
-export declare type ExecutionConfig<Default> = {
+export type ExecutionConfig<Default> = {
     execute: boolean;
     defaultValue: Default;
 };

package/{string → dist/string}/replace-in-template.d.ts

@@ -1,4 +1,4 @@
-export declare type ReplaceConfig = {
+export type ReplaceConfig = {
     delimiter: string | {
         left: string;
         right: string;

package/{time → dist/time}/get-time-diff-as-string.d.ts

@@ -1,4 +1,4 @@
-export declare type MonthLocaleLabels = [
+export type MonthLocaleLabels = [
     string,
     string,
     string,
@@ -12,7 +12,7 @@ export declare type MonthLocaleLabels = [
     string,
     string
 ];
-export declare type DiffTemplate = {
+export type DiffTemplate = {
     /**
      * e.g.: ("%time% %timelabel% blabla")
      */

package/dist/types/function.d.ts

@@ -0,0 +1 @@
+export type GenericFunction<TS extends any[], R> = (...args: TS) => R;

package/dist/types/general.d.ts

@@ -0,0 +1,8 @@
+export type Primitive = string | number | boolean;
+export type Nullable<T> = T | null;
+export type ValueType = Primitive | null | void | Array<any> | ReadonlyArray<any>;
+export type ValueOf<T> = T[keyof T];
+export type Range = {
+    min: number;
+    max: number;
+};

package/dist/types/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

package/{types → dist/types}/object.d.ts

@@ -1,30 +1,30 @@
 import { ValueType } from './general';
-export declare type NonMethodKeys<T> = {
+export type NonMethodKeys<T> = {
     [P in keyof T]: T[P] extends Function ? never : P;
 }[keyof T];
-export declare type Attributes<T> = {
+export type Attributes<T> = {
     [K in NonMethodKeys<T>]: T[K];
 };
-export declare type PartialAttributes<T> = {
+export type PartialAttributes<T> = {
     [K in NonMethodKeys<T>]?: T[K];
 };
-export declare type MethodKeys<T> = {
+export type MethodKeys<T> = {
     [P in keyof T]: T[P] extends Function ? P : never;
 }[keyof T];
-export declare type Methods<T> = {
+export type Methods<T> = {
     [K in MethodKeys<T>]: T[K];
 };
-export declare type PartialMethods<T> = {
+export type PartialMethods<T> = {
     [K in MethodKeys<T>]?: T[K];
 };
-export declare type ClassType<T, Params extends Array<any> = Array<any>> = {
+export type ClassType<T, Params extends Array<any> = Array<any>> = {
     new (...args: Params): T;
 };
-export declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-export declare type DeepPartial<T> = T extends ValueType ? T : {
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type DeepPartial<T> = T extends ValueType ? T : {
     [P in keyof T]?: DeepPartial<T[P]>;
 };
-export declare type Intersection<A, B> = {
+export type Intersection<A, B> = {
     [P in keyof A & keyof B]: A[P] | B[P];
 };
 /**
@@ -32,4 +32,4 @@ export declare type Intersection<A, B> = {
  * "widen" the type by accident if it is a generic that should be inferred
  * from elsewhere.
  */
-export declare type NoInfer<T> = [T][T extends any ? 0 : never];
+export type NoInfer<T> = [T][T extends any ? 0 : never];

package/dist/types/search.d.ts

@@ -0,0 +1,24 @@
+export type SearchSortBy = string;
+export type SearchSortOrder = 'asc' | 'desc';
+export type SearchSort = {
+    [by: SearchSortBy]: SearchSortOrder;
+};
+export type SearchQueryProperty = string;
+export type SearchQueryValue = string;
+export type SearchQuery = {
+    [property: SearchQueryProperty]: SearchQueryValue;
+};
+export type SearchObject = {
+    offset: number;
+    limit: number;
+    sort?: Record<string, SearchSortOrder>;
+    query?: SearchQuery;
+};
+export type SearchResponse<T> = {
+    items: ReadonlyArray<T>;
+    offset: number;
+    limit: number;
+    total: number;
+    next: string | null;
+    previous: string | null;
+};

package/global.d.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/no-extraneous-dependencies -- only needed during development
+import 'jest-extended';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparted/shared-library",
-  "version": "1.0.29",
+  "version": "1.1.0-rc0",
   "repository": "git@github.com:Sparted/shared-library.git",
   "author": {
     "name": "Sparted",
@@ -9,8 +9,7 @@
   },
   "license": "MIT",
   "sideEffets": false,
-  "main": "index.js",
-  "module": "index.js",
+  "main": "cjs/index.js",
   "files": [
     "**/*",
     "**/**"

package/rollup.config.ts

@@ -0,0 +1,19 @@
+import { glob } from 'glob';
+import typescript from 'rollup-plugin-typescript2';
+
+export default {
+  input: glob.sync('./src/**/index.ts'),
+  plugins: [
+    typescript({
+      exclude: ['**/__tests__', '**/*.test.ts'],
+    }),
+  ],
+  output: [
+    {
+      dir: 'dist',
+      format: 'cjs',
+      sourcemap: true,
+      preserveModules: true, // Keep directory structure and files
+    },
+  ],
+};

package/src/array/__tests__/array-to-map.test.ts

@@ -0,0 +1,50 @@
+import { arrayToMap } from '../array-to-map';
+
+type Item = {
+  id: string,
+  bar: number,
+};
+
+describe('arrayToMap', () => {
+  it('should convert array to map with item containing one key', () => {
+    const array = [{ id: 'toto' }, { id: 'bonjour' }];
+    const map = arrayToMap(array, { selectKey: ({ id }) => id });
+
+    expect(map).toStrictEqual({
+      bonjour: { id: 'bonjour' },
+      toto: { id: 'toto' },
+    });
+  });
+
+  it('should convert array to map and select right key in item', () => {
+    const array = [{ id: 'toto', bar: 1 }, { id: 'bonjour', bar: 2 }];
+    const map = arrayToMap(array, { selectKey: ({ bar }) => bar.toString() });
+
+    expect(map).toStrictEqual({
+      1: { id: 'toto', bar: 1 },
+      2: { id: 'bonjour', bar: 2 },
+    });
+  });
+
+  it('should handle data transformation', () => {
+    const item1: Item = { id: 'toto', bar: 1 };
+    const item2: Item = { id: 'bonjour', bar: 2 };
+    const array = [item1, item2];
+
+    const modifierFn = jest.fn();
+    const map = arrayToMap<Item, string>(array, {
+      selectKey: ({ bar }) => bar.toString(),
+      dataModifier: ({ id }, currentMap) => {
+        modifierFn(currentMap);
+        return id;
+      },
+    });
+
+    expect(modifierFn).toHaveBeenNthCalledWith(1, {});
+    expect(modifierFn).toHaveBeenNthCalledWith(2, { 1: 'toto' });
+    expect(map).toStrictEqual({
+      1: 'toto',
+      2: 'bonjour',
+    });
+  });
+});

package/src/array/__tests__/get-values-from-keys.test.ts

@@ -0,0 +1,14 @@
+import { valuesFromKeys } from '../get-values-from-keys';
+
+describe('valuesFromKeys', () => {
+  it('should transform a map to an array with only selected keys', () => {
+    const map = {
+      uno: 1,
+      dos: 2,
+      tres: 3,
+      quatro: 4,
+    };
+
+    expect(valuesFromKeys(['uno', 'tres'], map)).toStrictEqual([1, 3]);
+  });
+});

package/src/array/__tests__/inner-join.test.ts

@@ -0,0 +1,55 @@
+import { innerJoin } from '../inner-join';
+
+describe('innerJoin', () => {
+  it('should return an inner join of simple arrays', () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [3, 4, 5];
+
+    const innerJoinedArr = innerJoin(
+      arr1,
+      arr2,
+      (item) => item,
+      (item) => item,
+    );
+
+    expect(innerJoinedArr).toEqual([3]);
+  });
+
+  it('should return an inner join of complex array', () => {
+    const arr1 = [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Doe' },
+      { id: 3, name: 'Jane' },
+      { id: 4, name: 'Jack' },
+      { id: 5, name: 'Jill' },
+      { id: 6, name: 'Maurice' },
+    ];
+    const arr2 = [
+      { id: 3, name: 'Jane' },
+      { id: 4, name: 'Jack' },
+      { id: 5, name: 'Jill' },
+    ];
+
+    const innerJoinedArr = innerJoin(
+      arr1,
+      arr2,
+      (item) => item.id,
+      (item) => item.id,
+    );
+
+    expect(innerJoinedArr).toEqual([
+      {
+        id: 3,
+        name: 'Jane',
+      },
+      {
+        id: 4,
+        name: 'Jack',
+      },
+      {
+        id: 5,
+        name: 'Jill',
+      },
+    ]);
+  });
+});

package/src/array/__tests__/left-outter-join.test.ts

@@ -0,0 +1,55 @@
+import { leftOutterJoin } from '../left-outter-join';
+
+describe('leftOutterJoin', () => {
+  it('should return left outter joined of simple arrays', () => {
+    const arr1 = [1, 2, 3];
+    const arr2 = [3, 4, 5];
+
+    const leftOutterJoinedArr = leftOutterJoin(
+      arr1,
+      arr2,
+      (item) => item,
+      (item) => item,
+    );
+
+    expect(leftOutterJoinedArr).toEqual([1, 2]);
+  });
+
+  it('should return left outter joined of complex array', () => {
+    const arr1 = [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Doe' },
+      { id: 3, name: 'Jane' },
+      { id: 4, name: 'Jack' },
+      { id: 5, name: 'Jill' },
+      { id: 6, name: 'Maurice' },
+    ];
+    const arr2 = [
+      { id: 3, name: 'Jane' },
+      { id: 4, name: 'Jack' },
+      { id: 5, name: 'Jill' },
+    ];
+
+    const leftOutterJoinedArr = leftOutterJoin(
+      arr1,
+      arr2,
+      (item) => item.id,
+      (item) => item.id,
+    );
+
+    expect(leftOutterJoinedArr).toEqual([
+      {
+        id: 1,
+        name: 'John',
+      },
+      {
+        id: 2,
+        name: 'Doe',
+      },
+      {
+        id: 6,
+        name: 'Maurice',
+      },
+    ]);
+  });
+});

package/src/array/array-to-map.ts

@@ -0,0 +1,32 @@
+export type ArrayToMapOptions<InitialValue, ModifiedValue = InitialValue> = {
+  /**
+   * Function to return the key used in the map.
+   */
+  selectKey: (value: InitialValue) => string,
+  /**
+   * Transform the initial data into another value
+   */
+  dataModifier?: (value: InitialValue, map: Readonly<Record<string, ModifiedValue>>) => ModifiedValue;
+};
+
+/**
+ * Transform an array to a map.
+ */
+export const arrayToMap = <InitialValue, ModifiedValue = InitialValue>(
+  array: ReadonlyArray<InitialValue>,
+  options: ArrayToMapOptions<InitialValue, ModifiedValue>,
+) => {
+  const { selectKey } = options;
+
+  return array.reduce<Record<string, ModifiedValue>>((acc, current) => {
+    const key = selectKey(current);
+    const value = options.dataModifier
+      ? options.dataModifier(current, acc)
+      : current;
+
+    return {
+      ...acc,
+      [key]: value as ModifiedValue,
+    };
+  }, {});
+};

package/src/array/get-values-from-keys.ts

@@ -0,0 +1,3 @@
+export const valuesFromKeys = <T>(keys: string[], map: Record<string, T>) => (
+  keys.map((key) => map[key])
+);

package/src/array/index.ts

@@ -0,0 +1,4 @@
+export * from './array-to-map';
+export * from './get-values-from-keys';
+export * from './left-outter-join';
+export * from './inner-join';

package/src/array/inner-join.ts

@@ -0,0 +1,10 @@
+export const innerJoin = <T, U>(
+  arr1: T[],
+  arr2: U[],
+  selectKey1: (item: T) => string | number,
+  selectKey2: (item: U) => string | number,
+) => {
+  const arr2Set = new Set(arr2.map(selectKey2));
+
+  return arr1.filter((item) => arr2Set.has(selectKey1(item)));
+};

package/src/array/left-outter-join.ts

@@ -0,0 +1,10 @@
+export const leftOutterJoin = <T, U>(
+  arr1: T[],
+  arr2: U[],
+  selectKey1: (item: T) => string | number,
+  selectKey2: (item: U) => string | number,
+) => {
+  const arr2Set = new Set(arr2.map(selectKey2));
+
+  return arr1.filter((item) => !arr2Set.has(selectKey1(item)));
+};

package/src/business/picture-spot/index.ts

@@ -0,0 +1,3 @@
+import { PictureSpot } from '../types';
+
+export const getQuestions = (content: PictureSpot) => content.items?.map(({ question }) => question);