@sparted/shared-library 1.0.25 → 1.0.26

package/_virtual/_tslib.js

@@ -37,7 +37,12 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
-}
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
 
 exports.__awaiter = __awaiter;
 exports.__rest = __rest;

package/_virtual/_tslib.js.map

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

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

@@ -1,4 +1,4 @@
-export declare type ArrayToMapOptions<InitialValue, ModifiedValue = InitialValue> = {
+export type ArrayToMapOptions<InitialValue, ModifiedValue = InitialValue> = {
     /**
      * Function to return the key used in the map.
      */

package/array/index.d.ts

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

package/array/index.js

@@ -5,10 +5,12 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var arrayToMap = require('./array-to-map.js');
 var getValuesFromKeys = require('./get-values-from-keys.js');
 var leftOutterJoin = require('./left-outter-join.js');
+var innerJoin = require('./inner-join.js');
 
 
 
 exports.arrayToMap = arrayToMap.arrayToMap;
 exports.valuesFromKeys = getValuesFromKeys.valuesFromKeys;
 exports.leftOutterJoin = leftOutterJoin.leftOutterJoin;
+exports.innerJoin = innerJoin.innerJoin;
 //# sourceMappingURL=index.js.map

package/array/index.js.map

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

package/array/inner-join.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const innerJoin = (arr1, arr2, selectKey1, selectKey2) => {
+    const arr2Set = new Set(arr2.map(selectKey2));
+    return arr1.filter((item) => arr2Set.has(selectKey1(item)));
+};
+
+exports.innerJoin = innerJoin;
+//# sourceMappingURL=inner-join.js.map

package/array/inner-join.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inner-join.js","sources":["../../src/array/inner-join.ts"],"sourcesContent":["export const innerJoin = <T, U>(\n  arr1: T[],\n  arr2: U[],\n  selectKey1: (item: T) => string | number,\n  selectKey2: (item: U) => string | number,\n) => {\n  const arr2Set = new Set(arr2.map(selectKey2));\n\n  return arr1.filter((item) => arr2Set.has(selectKey1(item)));\n};\n"],"names":[],"mappings":";;;;AAAO,MAAM,SAAS,GAAG,CACvB,IAAS,EACT,IAAS,EACT,UAAwC,EACxC,UAAwC,KACtC;AACF,IAAA,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC;AAE9C,IAAA,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAC9D;;;;"}

package/cdn/types/cdn-factory.type.d.ts

@@ -1,5 +1,5 @@
-export declare type BaseUrlMapperFunc = (instanceId: string) => string;
-export declare type Transformation = {
+export type BaseUrlMapperFunc = (instanceId: string) => string;
+export type Transformation = {
     fit?: 'crop' | 'contain';
     width?: number;
     height?: number;
@@ -11,26 +11,26 @@ export declare type Transformation = {
     compress?: boolean;
     output?: 'jpeg' | 'png' | 'webp' | 'image';
 };
-export declare type CdnParams = {
+export type CdnParams = {
     asThumbnail?: boolean;
     transformation?: Transformation;
 };
-export declare type TransformationQueries = (params: Transformation) => string;
-declare type TwicpicsOutputTransformation = ['output', Transformation['output']];
-declare type TwicpicsFitTransformation = ['cover' | 'crop' | 'contain', string] | ['quality', number];
-export declare type TwicpicsTransformation = TwicpicsOutputTransformation | TwicpicsFitTransformation;
-export declare type TwicpicsTransformationChain = TwicpicsTransformation[];
-export declare type GetCdnUrl = (instanceId: string, path: `/${string}`, params?: CdnParams) => string;
-export declare type GetCdnFromS3Url = (url: string, params?: CdnParams) => string;
-export declare type InstanceMapper = (instanceId: string) => string;
-export declare type CdnType = 'twicpics' | 'imgix';
-export declare type CdnConfig<T extends CdnType> = {
+export type TransformationQueries = (params: Transformation) => string;
+type TwicpicsOutputTransformation = ['output', Transformation['output']];
+type TwicpicsFitTransformation = ['cover' | 'crop' | 'contain', string] | ['quality', number];
+export type TwicpicsTransformation = TwicpicsOutputTransformation | TwicpicsFitTransformation;
+export type TwicpicsTransformationChain = TwicpicsTransformation[];
+export type GetCdnUrl = (instanceId: string, path: `/${string}`, params?: CdnParams) => string;
+export type GetCdnFromS3Url = (url: string, params?: CdnParams) => string;
+export type InstanceMapper = (instanceId: string) => string;
+export type CdnType = 'twicpics' | 'imgix';
+export type CdnConfig<T extends CdnType> = {
     type: T;
     domain: `https://${string}`;
     instanceMapper: InstanceMapper;
     cacheVersion?: T extends 'twicpics' ? number : undefined;
 };
-export declare type Cdn = {
+export type Cdn = {
     getCdnUrl: GetCdnUrl;
     getCdnFromS3Url: GetCdnFromS3Url;
 };

package/cdn/utils/extract-info-from-url.util.d.ts

@@ -1,4 +1,4 @@
-declare type ExtractInfoFromUrl = (url: string) => {
+type ExtractInfoFromUrl = (url: string) => {
     instanceId: string;
     path: `/${string}`;
 } | undefined;

package/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/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/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/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/fetch-with-timeout.d.ts

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

package/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var arrayToMap = require('./array/array-to-map.js');
 var getValuesFromKeys = require('./array/get-values-from-keys.js');
 var leftOutterJoin = require('./array/left-outter-join.js');
+var innerJoin = require('./array/inner-join.js');
 var cdn_factory = require('./cdn/cdn.factory.js');
 var constants = require('./time/constants.js');
 var convert = require('./time/convert.js');
@@ -41,6 +42,7 @@ var replaceInTemplate = require('./string/replace-in-template.js');
 exports.arrayToMap = arrayToMap.arrayToMap;
 exports.valuesFromKeys = getValuesFromKeys.valuesFromKeys;
 exports.leftOutterJoin = leftOutterJoin.leftOutterJoin;
+exports.innerJoin = innerJoin.innerJoin;
 exports.createCdn = cdn_factory.createCdn;
 exports.MS_DAY = constants.MS_DAY;
 exports.MS_HOUR = constants.MS_HOUR;

package/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/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/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/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/number-range.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparted/shared-library",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "repository": "git@github.com:Sparted/shared-library.git",
   "author": {
     "name": "Sparted",

package/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/replace-in-template.d.ts

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

package/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/types/function.d.ts

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

package/types/general.d.ts

@@ -1,4 +1,4 @@
-export declare type Primitive = string | number | boolean;
-export declare type Nullable<T> = T | null;
-export declare type ValueType = Primitive | null | void | Array<any> | ReadonlyArray<any>;
-export declare type ValueOf<T> = T[keyof T];
+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];

package/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/types/search.d.ts

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