@digitraffic/common 2022.10.5

package/utils/api-model.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geojsonSchema = exports.featureSchema = exports.createArraySchema = exports.addSimpleServiceModel = exports.addServiceModel = exports.addDefaultValidator = exports.getModelReference = void 0;
+const aws_apigateway_1 = require("aws-cdk-lib/aws-apigateway");
+/**
+ * Get a reference to an OpenAPI model object in a REST API.
+ * Can be used to supply a reference to properties of a GeoJSON feature.
+ * @param modelId Id of the referenced object
+ * @param restApiId Id of the REST API
+ */
+function getModelReference(modelId, restApiId) {
+    return `https://apigateway.amazonaws.com/restapis/${restApiId}/models/${modelId}`;
+}
+exports.getModelReference = getModelReference;
+/**
+ * Adds a request validator to a REST API to enforce request parameters/body requirements.
+ * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html
+ * @param api REST API
+ */
+function addDefaultValidator(api) {
+    return api.addRequestValidator('DefaultValidator', {
+        validateRequestParameters: true,
+        validateRequestBody: true,
+    });
+}
+exports.addDefaultValidator = addDefaultValidator;
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _a single object._
+ * @param name Name of the model
+ * @param api REST API
+ * @param schema JSON Schema
+ * @return ModelWithReference A model object with a reference to an API Gateway model object.
+ */
+function addServiceModel(modelName, api, schema) {
+    const mwr = api.addModel(modelName, {
+        contentType: 'application/json',
+        modelName,
+        schema,
+    });
+    mwr.modelReference = getModelReference(mwr.modelId, api.restApiId);
+    return mwr;
+}
+exports.addServiceModel = addServiceModel;
+/**
+ * Add an empty JSON schema model to an API Gateway API.
+ * Usable for example if the incoming data is in XML format but some template transformation is necessary.
+ * @param modelName
+ * @param api
+ * @param contentType
+ */
+function addSimpleServiceModel(modelName, api, contentType = 'application/xml') {
+    return api.addModel(modelName, {
+        contentType,
+        modelName,
+        schema: {},
+    });
+}
+exports.addSimpleServiceModel = addSimpleServiceModel;
+/**
+ * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.
+ * This method adds a schema for _an array._
+ * @param model
+ * @param api
+ */
+function createArraySchema(model, api) {
+    return {
+        type: aws_apigateway_1.JsonSchemaType.ARRAY,
+        items: {
+            ref: getModelReference(model.modelId, api.restApiId),
+        },
+    };
+}
+exports.createArraySchema = createArraySchema;
+/**
+ * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object
+ */
+function featureSchema(modelReference) {
+    return {
+        schema: aws_apigateway_1.JsonSchemaVersion.DRAFT4,
+        type: aws_apigateway_1.JsonSchemaType.OBJECT,
+        description: 'GeoJson Feature',
+        required: ['type', 'properties', 'geometry'],
+        properties: {
+            type: {
+                type: aws_apigateway_1.JsonSchemaType.STRING,
+                description: 'Feature',
+                enum: ['Feature'],
+            },
+            properties: {
+                ref: modelReference,
+            },
+            geometry: {
+                type: aws_apigateway_1.JsonSchemaType.OBJECT,
+                description: 'GeoJSON geometry',
+            },
+        },
+    };
+}
+exports.featureSchema = featureSchema;
+/**
+ *
+ * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.
+ * @param modelReference Reference to a model object, in this case Features.
+ */
+function geojsonSchema(modelReference) {
+    return {
+        schema: aws_apigateway_1.JsonSchemaVersion.DRAFT4,
+        type: aws_apigateway_1.JsonSchemaType.OBJECT,
+        description: 'GeoJson FeatureCollection',
+        required: ['type', 'features'],
+        properties: {
+            type: {
+                type: aws_apigateway_1.JsonSchemaType.STRING,
+                description: 'FeatureCollection',
+                enum: ['FeatureCollection'],
+            },
+            features: {
+                type: aws_apigateway_1.JsonSchemaType.ARRAY,
+                items: {
+                    ref: modelReference,
+                },
+            },
+        },
+    };
+}
+exports.geojsonSchema = geojsonSchema;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-model.js","sourceRoot":"","sources":["../../src/utils/api-model.ts"],"names":[],"mappings":";;;AAAA,+DAOoC;AAGpC;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,OAAe,EAAE,SAAiB;IAChE,OAAO,6CAA6C,SAAS,WAAW,OAAO,EAAE,CAAC;AACtF,CAAC;AAFD,8CAEC;AAED;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,GAAY;IAC5C,OAAO,GAAG,CAAC,mBAAmB,CAAC,kBAAkB,EAAE;QAC/C,yBAAyB,EAAE,IAAI;QAC/B,mBAAmB,EAAE,IAAI;KAC5B,CAAC,CAAC;AACP,CAAC;AALD,kDAKC;AAED;;;;;;;GAOG;AACH,SAAgB,eAAe,CAAC,SAAiB,EAAE,GAAY,EAAE,MAAkB;IAC/E,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,SAAS,EAAE;QAChC,WAAW,EAAE,kBAAkB;QAC/B,SAAS;QACT,MAAM;KACT,CAAuB,CAAC;IACzB,GAAG,CAAC,cAAc,GAAG,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;IACnE,OAAO,GAAG,CAAC;AACf,CAAC;AARD,0CAQC;AAED;;;;;;GAMG;AACH,SAAgB,qBAAqB,CAAC,SAAiB,EAAE,GAAY,EAAE,WAAW,GAAG,iBAAiB;IAClG,OAAO,GAAG,CAAC,QAAQ,CAAC,SAAS,EAAE;QAC3B,WAAW;QACX,SAAS;QACT,MAAM,EAAE,EAAE;KACb,CAAC,CAAC;AACP,CAAC;AAND,sDAMC;AAED;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,KAAY,EAAE,GAAY;IACxD,OAAO;QACH,IAAI,EAAE,+BAAc,CAAC,KAAK;QAC1B,KAAK,EAAE;YACH,GAAG,EAAE,iBAAiB,CAAC,KAAK,CAAC,OAAO,EAAE,GAAG,CAAC,SAAS,CAAC;SACvD;KACJ,CAAC;AACN,CAAC;AAPD,8CAOC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,cAAsB;IAChD,OAAO;QACH,MAAM,EAAE,kCAAiB,CAAC,MAAM;QAChC,IAAI,EAAE,+BAAc,CAAC,MAAM;QAC3B,WAAW,EAAE,iBAAiB;QAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,CAAC;QAC5C,UAAU,EAAE;YACR,IAAI,EAAE;gBACF,IAAI,EAAE,+BAAc,CAAC,MAAM;gBAC3B,WAAW,EAAE,SAAS;gBACtB,IAAI,EAAE,CAAC,SAAS,CAAC;aACpB;YACD,UAAU,EAAE;gBACR,GAAG,EAAE,cAAc;aACtB;YACD,QAAQ,EAAE;gBACN,IAAI,EAAE,+BAAc,CAAC,MAAM;gBAC3B,WAAW,EAAE,kBAAkB;aAClC;SACJ;KACJ,CAAC;AACN,CAAC;AArBD,sCAqBC;AAED;;;;GAIG;AACH,SAAgB,aAAa,CAAC,cAAsB;IAChD,OAAO;QACH,MAAM,EAAE,kCAAiB,CAAC,MAAM;QAChC,IAAI,EAAE,+BAAc,CAAC,MAAM;QAC3B,WAAW,EAAE,2BAA2B;QACxC,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,CAAC;QAC9B,UAAU,EAAE;YACR,IAAI,EAAE;gBACF,IAAI,EAAE,+BAAc,CAAC,MAAM;gBAC3B,WAAW,EAAE,mBAAmB;gBAChC,IAAI,EAAE,CAAC,mBAAmB,CAAC;aAC9B;YACD,QAAQ,EAAE;gBACN,IAAI,EAAE,+BAAc,CAAC,KAAK;gBAC1B,KAAK,EAAE;oBACH,GAAG,EAAE,cAAc;iBACtB;aACJ;SACJ;KACJ,CAAC;AACN,CAAC;AApBD,sCAoBC","sourcesContent":["import {\n    RestApi,\n    Model,\n    JsonSchema,\n    RequestValidator,\n    JsonSchemaType,\n    JsonSchemaVersion,\n} from 'aws-cdk-lib/aws-apigateway';\nimport {ModelWithReference} from \"../aws/types/model-with-reference\";\n\n/**\n * Get a reference to an OpenAPI model object in a REST API.\n * Can be used to supply a reference to properties of a GeoJSON feature.\n * @param modelId Id of the referenced object\n * @param restApiId Id of the REST API\n */\nexport function getModelReference(modelId: string, restApiId: string) {\n    return `https://apigateway.amazonaws.com/restapis/${restApiId}/models/${modelId}`;\n}\n\n/**\n * Adds a request validator to a REST API to enforce request parameters/body requirements.\n * https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-method-request-validation.html\n * @param api REST API\n */\nexport function addDefaultValidator(api: RestApi): RequestValidator {\n    return api.addRequestValidator('DefaultValidator', {\n        validateRequestParameters: true,\n        validateRequestBody: true,\n    });\n}\n\n/**\n * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.\n * This method adds a schema for _a single object._\n * @param name Name of the model\n * @param api REST API\n * @param schema JSON Schema\n * @return ModelWithReference A model object with a reference to an API Gateway model object.\n */\nexport function addServiceModel(modelName: string, api: RestApi, schema: JsonSchema): ModelWithReference {\n    const mwr = api.addModel(modelName, {\n        contentType: 'application/json',\n        modelName,\n        schema,\n    }) as ModelWithReference;\n    mwr.modelReference = getModelReference(mwr.modelId, api.restApiId);\n    return mwr;\n}\n\n/**\n * Add an empty JSON schema model to an API Gateway API.\n * Usable for example if the incoming data is in XML format but some template transformation is necessary.\n * @param modelName\n * @param api\n * @param contentType\n */\nexport function addSimpleServiceModel(modelName: string, api: RestApi, contentType = 'application/xml'): Model {\n    return api.addModel(modelName, {\n        contentType,\n        modelName,\n        schema: {},\n    });\n}\n\n/**\n * Adds a JSON Schema model to an API Gateway API. Can be used later to generate OpenAPI specifications.\n * This method adds a schema for _an array._\n * @param model\n * @param api\n */\nexport function createArraySchema(model: Model, api: RestApi): JsonSchema {\n    return {\n        type: JsonSchemaType.ARRAY,\n        items: {\n            ref: getModelReference(model.modelId, api.restApiId),\n        },\n    };\n}\n\n/**\n * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.\n * @param modelReference Reference to a model object\n */\nexport function featureSchema(modelReference: string) {\n    return {\n        schema: JsonSchemaVersion.DRAFT4,\n        type: JsonSchemaType.OBJECT,\n        description: 'GeoJson Feature',\n        required: ['type', 'properties', 'geometry'],\n        properties: {\n            type: {\n                type: JsonSchemaType.STRING,\n                description: 'Feature',\n                enum: ['Feature'],\n            },\n            properties: {\n                ref: modelReference,\n            },\n            geometry: {\n                type: JsonSchemaType.OBJECT,\n                description: 'GeoJSON geometry',\n            },\n        },\n    };\n}\n\n/**\n *\n * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.\n * @param modelReference Reference to a model object, in this case Features.\n */\nexport function geojsonSchema(modelReference: string) {\n    return {\n        schema: JsonSchemaVersion.DRAFT4,\n        type: JsonSchemaType.OBJECT,\n        description: 'GeoJson FeatureCollection',\n        required: ['type', 'features'],\n        properties: {\n            type: {\n                type: JsonSchemaType.STRING,\n                description: 'FeatureCollection',\n                enum: ['FeatureCollection'],\n            },\n            features: {\n                type: JsonSchemaType.ARRAY,\n                items: {\n                    ref: modelReference,\n                },\n            },\n        },\n    };\n}\n"]}

package/utils/base64.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/**
+ * Decode given string from base64 to ascii
+ * @param str string
+ */
+export declare function decodeBase64ToAscii(str: string): string;
+/**
+ * Decode given string from base64 to given encoding
+ * @param str
+ * @param encoding
+ */
+export declare function decodeBase64(str: string, encoding: BufferEncoding): string;

package/utils/base64.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBase64 = exports.decodeBase64ToAscii = void 0;
+/**
+ * Decode given string from base64 to ascii
+ * @param str string
+ */
+function decodeBase64ToAscii(str) {
+    return decodeBase64(str, 'ascii');
+}
+exports.decodeBase64ToAscii = decodeBase64ToAscii;
+/**
+ * Decode given string from base64 to given encoding
+ * @param str
+ * @param encoding
+ */
+function decodeBase64(str, encoding) {
+    return Buffer.from(str, 'base64').toString(encoding);
+}
+exports.decodeBase64 = decodeBase64;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZTY0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2Jhc2U2NC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7O0dBR0c7QUFDSCxTQUFnQixtQkFBbUIsQ0FBQyxHQUFXO0lBQzNDLE9BQU8sWUFBWSxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUN0QyxDQUFDO0FBRkQsa0RBRUM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsWUFBWSxDQUFDLEdBQVcsRUFBRSxRQUF3QjtJQUM5RCxPQUFPLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLFFBQVEsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUN6RCxDQUFDO0FBRkQsb0NBRUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlY29kZSBnaXZlbiBzdHJpbmcgZnJvbSBiYXNlNjQgdG8gYXNjaWlcbiAqIEBwYXJhbSBzdHIgc3RyaW5nXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVCYXNlNjRUb0FzY2lpKHN0cjogc3RyaW5nKSB7XG4gICAgcmV0dXJuIGRlY29kZUJhc2U2NChzdHIsICdhc2NpaScpO1xufVxuXG4vKipcbiAqIERlY29kZSBnaXZlbiBzdHJpbmcgZnJvbSBiYXNlNjQgdG8gZ2l2ZW4gZW5jb2RpbmdcbiAqIEBwYXJhbSBzdHJcbiAqIEBwYXJhbSBlbmNvZGluZ1xuICovXG5leHBvcnQgZnVuY3Rpb24gZGVjb2RlQmFzZTY0KHN0cjogc3RyaW5nLCBlbmNvZGluZzogQnVmZmVyRW5jb2RpbmcpIHtcbiAgICByZXR1cm4gQnVmZmVyLmZyb20oc3RyLCAnYmFzZTY0JykudG9TdHJpbmcoZW5jb2RpbmcpO1xufVxuIl19

package/utils/date-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+export declare function countDiffMs(start: Date, end: Date): number;
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+export declare function countDiffInSeconds(start: Date, end: Date): number;
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+export declare function dateFromIsoString(isoString: string): Date;

package/utils/date-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateFromIsoString = exports.countDiffInSeconds = exports.countDiffMs = void 0;
+/**
+ * Counts difference in milliseconds between dates.
+ * @param start
+ * @param end
+ */
+function countDiffMs(start, end) {
+    return end.getTime() - start.getTime();
+}
+exports.countDiffMs = countDiffMs;
+/**
+ * Counts difference in seconds between dates.
+ * @param start
+ * @param end
+ */
+function countDiffInSeconds(start, end) {
+    return countDiffMs(start, end) / 1000;
+}
+exports.countDiffInSeconds = countDiffInSeconds;
+/**
+ * Converts ISO 8601 date-time -string to Date object
+ * @param isoString to convert
+ */
+function dateFromIsoString(isoString) {
+    const parsed = new Date(isoString);
+    if (!(parsed instanceof Date) || isNaN(parsed.getTime())) {
+        throw new Error(`Invalid ISO-DATE -string: ${isoString}`);
+    }
+    return parsed;
+}
+exports.dateFromIsoString = dateFromIsoString;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9kYXRlLXV0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBOzs7O0dBSUc7QUFDSCxTQUFnQixXQUFXLENBQUMsS0FBVyxFQUFFLEdBQVM7SUFDOUMsT0FBTyxHQUFHLENBQUMsT0FBTyxFQUFFLEdBQUcsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO0FBQzNDLENBQUM7QUFGRCxrQ0FFQztBQUVEOzs7O0dBSUc7QUFDSCxTQUFnQixrQkFBa0IsQ0FBQyxLQUFXLEVBQUUsR0FBUztJQUNyRCxPQUFPLFdBQVcsQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLEdBQUMsSUFBSSxDQUFDO0FBQ3hDLENBQUM7QUFGRCxnREFFQztBQUVEOzs7R0FHRztBQUNILFNBQWdCLGlCQUFpQixDQUFDLFNBQWlCO0lBQy9DLE1BQU0sTUFBTSxHQUFHLElBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ25DLElBQUksQ0FBQyxDQUFDLE1BQU0sWUFBWSxJQUFJLENBQUMsSUFBSSxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxDQUFDLEVBQUU7UUFDdEQsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsU0FBUyxFQUFFLENBQUMsQ0FBQztLQUM3RDtJQUNELE9BQU8sTUFBTSxDQUFDO0FBQ2xCLENBQUM7QUFORCw4Q0FNQyIsInNvdXJjZXNDb250ZW50IjpbIlxuLyoqXG4gKiBDb3VudHMgZGlmZmVyZW5jZSBpbiBtaWxsaXNlY29uZHMgYmV0d2VlbiBkYXRlcy5cbiAqIEBwYXJhbSBzdGFydFxuICogQHBhcmFtIGVuZFxuICovXG5leHBvcnQgZnVuY3Rpb24gY291bnREaWZmTXMoc3RhcnQ6IERhdGUsIGVuZDogRGF0ZSk6IG51bWJlciB7XG4gICAgcmV0dXJuIGVuZC5nZXRUaW1lKCkgLSBzdGFydC5nZXRUaW1lKCk7XG59XG5cbi8qKlxuICogQ291bnRzIGRpZmZlcmVuY2UgaW4gc2Vjb25kcyBiZXR3ZWVuIGRhdGVzLlxuICogQHBhcmFtIHN0YXJ0XG4gKiBAcGFyYW0gZW5kXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb3VudERpZmZJblNlY29uZHMoc3RhcnQ6IERhdGUsIGVuZDogRGF0ZSk6IG51bWJlciB7XG4gICAgcmV0dXJuIGNvdW50RGlmZk1zKHN0YXJ0LCBlbmQpLzEwMDA7XG59XG5cbi8qKlxuICogQ29udmVydHMgSVNPIDg2MDEgZGF0ZS10aW1lIC1zdHJpbmcgdG8gRGF0ZSBvYmplY3RcbiAqIEBwYXJhbSBpc29TdHJpbmcgdG8gY29udmVydFxuICovXG5leHBvcnQgZnVuY3Rpb24gZGF0ZUZyb21Jc29TdHJpbmcoaXNvU3RyaW5nOiBzdHJpbmcpOiBEYXRlIHtcbiAgICBjb25zdCBwYXJzZWQgPSBuZXcgRGF0ZShpc29TdHJpbmcpO1xuICAgIGlmICghKHBhcnNlZCBpbnN0YW5jZW9mIERhdGUpIHx8IGlzTmFOKHBhcnNlZC5nZXRUaW1lKCkpKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgSW52YWxpZCBJU08tREFURSAtc3RyaW5nOiAke2lzb1N0cmluZ31gKTtcbiAgICB9XG4gICAgcmV0dXJuIHBhcnNlZDtcbn1cbiJdfQ==

package/utils/geojson-types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GeoJSON types
+ */
+import { LineString, Point, Position } from "geojson";
+export declare class GeoJsonPoint implements Point {
+    readonly type = "Point";
+    readonly coordinates: Position;
+    constructor(coordinates: Position);
+}
+export declare class GeoJsonLineString implements LineString {
+    readonly type = "LineString";
+    readonly coordinates: Position[];
+    constructor(coordinates: Position[]);
+}

package/utils/geojson-types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeoJsonLineString = exports.GeoJsonPoint = void 0;
+class GeoJsonPoint {
+    constructor(coordinates) {
+        this.type = "Point";
+        this.coordinates = coordinates;
+    }
+}
+exports.GeoJsonPoint = GeoJsonPoint;
+class GeoJsonLineString {
+    constructor(coordinates) {
+        this.type = "LineString";
+        this.coordinates = coordinates;
+    }
+}
+exports.GeoJsonLineString = GeoJsonLineString;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VvanNvbi10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9nZW9qc29uLXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUtBLE1BQWEsWUFBWTtJQUlyQixZQUFZLFdBQXFCO1FBSHhCLFNBQUksR0FBRyxPQUFPLENBQUM7UUFJcEIsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7SUFDbkMsQ0FBQztDQUNKO0FBUEQsb0NBT0M7QUFFRCxNQUFhLGlCQUFpQjtJQUkxQixZQUFZLFdBQXVCO1FBSDFCLFNBQUksR0FBRyxZQUFZLENBQUM7UUFJekIsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7SUFDbkMsQ0FBQztDQUNKO0FBUEQsOENBT0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlb0pTT04gdHlwZXNcbiAqL1xuaW1wb3J0IHtMaW5lU3RyaW5nLCBQb2ludCwgUG9zaXRpb259IGZyb20gXCJnZW9qc29uXCI7XG5cbmV4cG9ydCBjbGFzcyBHZW9Kc29uUG9pbnQgaW1wbGVtZW50cyBQb2ludCB7XG4gICAgcmVhZG9ubHkgdHlwZSA9IFwiUG9pbnRcIjtcbiAgICByZWFkb25seSBjb29yZGluYXRlczogUG9zaXRpb247XG5cbiAgICBjb25zdHJ1Y3Rvcihjb29yZGluYXRlczogUG9zaXRpb24pIHtcbiAgICAgICAgdGhpcy5jb29yZGluYXRlcyA9IGNvb3JkaW5hdGVzO1xuICAgIH1cbn1cblxuZXhwb3J0IGNsYXNzIEdlb0pzb25MaW5lU3RyaW5nIGltcGxlbWVudHMgTGluZVN0cmluZyB7XG4gICAgcmVhZG9ubHkgdHlwZSA9IFwiTGluZVN0cmluZ1wiO1xuICAgIHJlYWRvbmx5IGNvb3JkaW5hdGVzOiBQb3NpdGlvbltdO1xuXG4gICAgY29uc3RydWN0b3IoY29vcmRpbmF0ZXM6IFBvc2l0aW9uW10pIHtcbiAgICAgICAgdGhpcy5jb29yZGluYXRlcyA9IGNvb3JkaW5hdGVzO1xuICAgIH1cbn1cbiJdfQ==

package/utils/geometry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * GeoJSON functions and tools
+ */
+import { Feature, FeatureCollection, Geometry, Position } from "geojson";
+export declare const SRID_WGS84 = 4326;
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+export declare function createGeometry(geometry: Geometry): string;
+/**
+ * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property
+ * @param features List of Features
+ * @param lastUpdated Last updated date
+ */
+export declare function createFeatureCollection(features: Feature[], lastUpdated: Date | null): FeatureCollection;
+export declare function isValidGeoJson<T>(json: T): boolean;
+export declare function isFeatureCollection<T>(json: T): boolean;
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+export declare function distanceBetweenPositionsInKm(pos1: Position, pos2: Position): number;
+export declare function areDistinctPositions(previous: Position, next: Position): boolean;
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+export declare function distanceBetweenPositionsInM(pos1: Position, pos2: Position): number;
+export declare function createGmlLineString(geometry: Geometry, srsName?: string): {
+    srsName: string;
+    posList: string;
+};
+export declare function positionToList(position: Position, precision?: number): string;

package/utils/geometry.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.positionToList = exports.createGmlLineString = exports.distanceBetweenPositionsInM = exports.areDistinctPositions = exports.distanceBetweenPositionsInKm = exports.isFeatureCollection = exports.isValidGeoJson = exports.createFeatureCollection = exports.createGeometry = exports.SRID_WGS84 = void 0;
+exports.SRID_WGS84 = 4326;
+/**
+ * Creates WKT geometry from GeoJSON geometry
+ * @param geometry GeoJson geometry to convert to WKT
+ */
+function createGeometry(geometry) {
+    if (geometry.type === 'LineString') {
+        const coordinates = linestring(geometry.coordinates);
+        return `LINESTRING(${coordinates})`;
+    }
+    else if (geometry.type === 'Point') {
+        const coordinates = coordinatePair(geometry.coordinates);
+        return `POINT(${coordinates})`;
+    }
+    else if (geometry.type === 'Polygon') {
+        const coordinates = polygon(geometry.coordinates);
+        return `POLYGON(${coordinates})`;
+    }
+    else if (geometry.type === 'MultiPolygon') {
+        const coordinates = multiPolygon(geometry.coordinates);
+        return `MULTIPOLYGON(${coordinates})`;
+    }
+    console.error("unsupported locationType=%s", geometry.type);
+    return "POLYGON EMPTY";
+}
+exports.createGeometry = createGeometry;
+function linestring(coordinates) {
+    return coordinates.map((c) => coordinatePair(c)).join(',');
+}
+function polygon(coordinates) {
+    const list = coordinates.map((c) => linestring(c)).join(',');
+    return `(${list})`;
+}
+function multiPolygon(coordinates) {
+    const list = coordinates.map((c) => polygon(c)).join(',');
+    return `(${list})`;
+}
+function coordinatePair(coordinate) {
+    return `${coordinate[0]} ${coordinate[1]}`;
+}
+/**
+ * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property
+ * @param features List of Features
+ * @param lastUpdated Last updated date
+ */
+function createFeatureCollection(features, lastUpdated) {
+    return {
+        type: "FeatureCollection",
+        lastUpdated: lastUpdated,
+        features: features,
+    };
+}
+exports.createFeatureCollection = createFeatureCollection;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const geoJsonValidator = require('geojson-validation');
+function isValidGeoJson(json) {
+    return geoJsonValidator.valid(json);
+}
+exports.isValidGeoJson = isValidGeoJson;
+function isFeatureCollection(json) {
+    return geoJsonValidator.isFeatureCollection(json);
+}
+exports.isFeatureCollection = isFeatureCollection;
+const DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180
+const EARTH_RADIUS_KM = 6371;
+/**
+ * Returns the distance between this and given GeoJSON point in kilometers. Doesn't take in account altitude.
+ * Based on the following Stack Overflow question:
+ * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,
+ * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).
+ */
+function distanceBetweenWGS84PointsInKm(fromXLon, fromYLat, toXLon, toYLat) {
+    const diffLat = toRadians(toYLat - fromYLat);
+    const diffLon = toRadians(toXLon - fromXLon);
+    const a = Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +
+        Math.cos(toRadians(fromYLat)) * Math.cos(toRadians(toYLat)) *
+            Math.sin(diffLon / 2) * Math.sin(diffLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return EARTH_RADIUS_KM * c;
+}
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+function distanceBetweenPositionsInKm(pos1, pos2) {
+    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);
+}
+exports.distanceBetweenPositionsInKm = distanceBetweenPositionsInKm;
+function areDistinctPositions(previous, next) {
+    return previous[0] !== next[0] || previous[1] !== next[1];
+}
+exports.areDistinctPositions = areDistinctPositions;
+/**
+ * Calculates distance between two GeoJSON points (WGS84)
+ * @param pos1
+ * @param pos2
+ */
+function distanceBetweenPositionsInM(pos1, pos2) {
+    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m
+}
+exports.distanceBetweenPositionsInM = distanceBetweenPositionsInM;
+function createGmlLineString(geometry, srsName = 'EPSG:4326') {
+    const posList = createPosList(geometry);
+    return {
+        srsName,
+        posList,
+    };
+}
+exports.createGmlLineString = createGmlLineString;
+function createPosList(geometry) {
+    if (geometry.type === 'Point') {
+        return positionToList(geometry.coordinates);
+    }
+    else if (geometry.type === 'LineString') {
+        return lineStringToList(geometry.coordinates);
+    }
+    else if (geometry.type === 'Polygon') {
+        return polygonToList(geometry.coordinates);
+    }
+    throw new Error("unknown geometry type " + JSON.stringify(geometry));
+}
+function polygonToList(positions, precision = 8) {
+    return positions.map(p => lineStringToList(p, precision)).join(' ');
+}
+function lineStringToList(positions, precision = 8) {
+    return positions.map(p => positionToList(p, precision)).join(' ');
+}
+function positionToList(position, precision = 8) {
+    return position.map(n => n.toPrecision(precision)).join(' ');
+}
+exports.positionToList = positionToList;
+// Converts numeric degrees to radians
+function toRadians(angdeg) {
+    return angdeg * DEGREES_TO_RADIANS;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../src/utils/geometry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * GeoJSON functions and tools\r\n */\r\nimport {Feature, FeatureCollection, Geometry, Position} from \"geojson\";\r\n\r\nexport const SRID_WGS84 = 4326;\r\n\r\n/**\r\n * Creates WKT geometry from GeoJSON geometry\r\n * @param geometry GeoJson geometry to convert to WKT\r\n */\r\nexport function createGeometry(geometry: Geometry): string {\r\n    if (geometry.type === 'LineString') {\r\n        const coordinates = linestring(geometry.coordinates);\r\n\r\n        return `LINESTRING(${coordinates})`;\r\n    } else if (geometry.type === 'Point') {\r\n        const coordinates = coordinatePair(geometry.coordinates);\r\n\r\n        return `POINT(${coordinates})`;\r\n    } else if (geometry.type === 'Polygon') {\r\n        const coordinates = polygon(geometry.coordinates);\r\n\r\n        return `POLYGON(${coordinates})`;\r\n    } else if (geometry.type === 'MultiPolygon') {\r\n        const coordinates = multiPolygon(geometry.coordinates);\r\n\r\n        return `MULTIPOLYGON(${coordinates})`;\r\n    }\r\n\r\n    console.error(\"unsupported locationType=%s\", geometry.type);\r\n    return \"POLYGON EMPTY\";\r\n}\r\n\r\nfunction linestring(coordinates: Position[]): string {\r\n    return coordinates.map((c: Position) =>  coordinatePair(c)).join(',');\r\n}\r\n\r\nfunction polygon(coordinates: Position[][]):string {\r\n    const list = coordinates.map((c: Position[]) => linestring(c)).join(',');\r\n    return `(${list})`;\r\n}\r\n\r\nfunction multiPolygon(coordinates: Position[][][]):string {\r\n    const list = coordinates.map((c: Position[][]) => polygon(c)).join(',');\r\n    return `(${list})`;\r\n}\r\n\r\nfunction coordinatePair(coordinate: Position): string {\r\n    return `${coordinate[0]} ${coordinate[1]}`;\r\n}\r\n\r\n/**\r\n * Create a GeoJSON FeatureCollection from a list of GeoJSON features with a 'last updated' property\r\n * @param features List of Features\r\n * @param lastUpdated Last updated date\r\n */\r\nexport function createFeatureCollection(features: Feature[], lastUpdated: Date | null): FeatureCollection {\r\n    return {\r\n        type: \"FeatureCollection\",\r\n        lastUpdated: lastUpdated,\r\n        features: features,\r\n    } as FeatureCollection;\r\n}\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-var-requires\r\nconst geoJsonValidator = require('geojson-validation');\r\n\r\nexport function isValidGeoJson<T>(json: T): boolean {\r\n    return geoJsonValidator.valid(json);\r\n}\r\n\r\nexport function isFeatureCollection<T>(json: T): boolean {\r\n    return geoJsonValidator.isFeatureCollection(json);\r\n}\r\n\r\nconst DEGREES_TO_RADIANS = 0.017453292519943295; // = Math.PI / 180\r\nconst EARTH_RADIUS_KM = 6371;\r\n\r\n\r\n/**\r\n * Returns the distance between this and given GeoJSON point in kilometers. Doesn't take in account altitude.\r\n * Based on the following Stack Overflow question:\r\n * http://stackoverflow.com/questions/27928/calculate-distance-between-two-latitude-longitude-points-haversine-formula,\r\n * which is based on https://en.wikipedia.org/wiki/Haversine_formula (error rate: ~0.55%).\r\n */\r\nfunction distanceBetweenWGS84PointsInKm(fromXLon:number, fromYLat:number, toXLon:number, toYLat:number): number  {\r\n\r\n    const diffLat = toRadians(toYLat - fromYLat);\r\n    const diffLon = toRadians(toXLon - fromXLon);\r\n\r\n    const a =\r\n        Math.sin(diffLat / 2) * Math.sin(diffLat / 2) +\r\n        Math.cos(toRadians(fromYLat)) * Math.cos(toRadians(toYLat)) *\r\n        Math.sin(diffLon / 2) * Math.sin(diffLon / 2);\r\n    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\r\n    return EARTH_RADIUS_KM * c;\r\n}\r\n\r\n/**\r\n * Calculates distance between two GeoJSON points (WGS84)\r\n * @param pos1\r\n * @param pos2\r\n */\r\nexport function distanceBetweenPositionsInKm(pos1: Position, pos2: Position) {\r\n    return distanceBetweenWGS84PointsInKm(pos1[0], pos1[1], pos2[0], pos2[1]);\r\n}\r\n\r\nexport function areDistinctPositions(previous: Position, next: Position) {\r\n    return previous[0] !== next[0] || previous[1] !== next[1];\r\n}\r\n\r\n/**\r\n * Calculates distance between two GeoJSON points (WGS84)\r\n * @param pos1\r\n * @param pos2\r\n */\r\nexport function distanceBetweenPositionsInM(pos1: Position, pos2: Position) {\r\n    return distanceBetweenPositionsInKm(pos1, pos2) * 1000; // km -> m\r\n}\r\n\r\nexport function createGmlLineString(geometry: Geometry, srsName = 'EPSG:4326') {\r\n    const posList = createPosList(geometry);\r\n\r\n    return {\r\n        srsName,\r\n        posList,\r\n    };\r\n}\r\n\r\nfunction createPosList(geometry: Geometry) {\r\n    if (geometry.type === 'Point') {\r\n        return positionToList(geometry.coordinates);\r\n    } else if (geometry.type === 'LineString') {\r\n        return lineStringToList(geometry.coordinates);\r\n    } else if (geometry.type === 'Polygon') {\r\n        return polygonToList(geometry.coordinates);\r\n    }\r\n\r\n    throw new Error(\"unknown geometry type \" + JSON.stringify(geometry));\r\n}\r\n\r\nfunction polygonToList(positions: Position[][], precision = 8) {\r\n    return positions.map(p => lineStringToList(p, precision)).join(' ');\r\n}\r\n\r\nfunction lineStringToList(positions: Position[], precision = 8) {\r\n    return positions.map(p => positionToList(p, precision)).join(' ');\r\n}\r\n\r\nexport function positionToList(position: Position, precision = 8) {\r\n    return position.map(n => n.toPrecision(precision)).join(' ');\r\n}\r\n\r\n// Converts numeric degrees to radians\r\nfunction toRadians(angdeg:number) {\r\n    return angdeg * DEGREES_TO_RADIANS;\r\n}\r\n"]}

package/utils/retry.d.ts

@@ -0,0 +1,13 @@
+export declare enum RetryLogError {
+    LOG_ALL_AS_ERRORS = 0,
+    LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS = 1,
+    NO_LOGGING = 2
+}
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @return Promise return value
+ */
+export declare function retry<T>(asyncFn: () => Promise<T>, retries?: number, logError?: RetryLogError): Promise<T>;

package/utils/retry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retry = exports.RetryLogError = void 0;
+var RetryLogError;
+(function (RetryLogError) {
+    RetryLogError[RetryLogError["LOG_ALL_AS_ERRORS"] = 0] = "LOG_ALL_AS_ERRORS";
+    RetryLogError[RetryLogError["LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS"] = 1] = "LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS";
+    RetryLogError[RetryLogError["NO_LOGGING"] = 2] = "NO_LOGGING";
+})(RetryLogError = exports.RetryLogError || (exports.RetryLogError = {}));
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @return Promise return value
+ */
+async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+    if (!isFinite(retries)) {
+        throw new Error('Only finite numbers are supported');
+    }
+    if (retries > 100) {
+        throw new Error('Exceeded the maximum retry count of 100');
+    }
+    try {
+        return await asyncFn();
+    }
+    catch (error) {
+        const remainingRetries = retries - 1;
+        const errorMessage = 'method=retry error';
+        if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
+            console.error(errorMessage, error);
+        }
+        else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+            if (remainingRetries < 0) {
+                console.error(errorMessage, error);
+            }
+            else {
+                console.warn(errorMessage, error);
+            }
+        }
+        if (remainingRetries < 0) {
+            console.warn('method=retry no retries left');
+            throw new Error('No retries left');
+        }
+        console.warn('method=retry invocation failed, retrying with remaining retries %d', remainingRetries);
+        return retry(asyncFn, remainingRetries, logError);
+    }
+}
+exports.retry = retry;
+//# sourceMappingURL=data:application/json;base64,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

package/utils/slack.d.ts

@@ -0,0 +1,5 @@
+export declare class SlackApi {
+    private readonly url;
+    constructor(url: string);
+    notify(text: string): Promise<void>;
+}

package/utils/slack.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+class SlackApi {
+    constructor(url) {
+        this.url = url;
+    }
+    async notify(text) {
+        try {
+            console.info('method=notify Notifying Slack');
+            await axios_1.default.post(this.url, {
+                text,
+            });
+        }
+        catch (error) {
+            console.error('method=notify Slack notify failed!');
+        }
+    }
+}
+exports.SlackApi = SlackApi;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvc2xhY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsa0RBQTBCO0FBRTFCLE1BQWEsUUFBUTtJQUlqQixZQUFZLEdBQVc7UUFDbkIsSUFBSSxDQUFDLEdBQUcsR0FBRyxHQUFHLENBQUM7SUFDbkIsQ0FBQztJQUVELEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBWTtRQUNyQixJQUFJO1lBQ0EsT0FBTyxDQUFDLElBQUksQ0FBQywrQkFBK0IsQ0FBQyxDQUFDO1lBQzlDLE1BQU0sZUFBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFO2dCQUN2QixJQUFJO2FBQ1AsQ0FBQyxDQUFDO1NBQ047UUFBQyxPQUFPLEtBQUssRUFBRTtZQUNaLE9BQU8sQ0FBQyxLQUFLLENBQUMsb0NBQW9DLENBQUMsQ0FBQztTQUN2RDtJQUNMLENBQUM7Q0FFSjtBQW5CRCw0QkFtQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgYXhpb3MgZnJvbSBcImF4aW9zXCI7XG5cbmV4cG9ydCBjbGFzcyBTbGFja0FwaSB7XG5cbiAgICBwcml2YXRlIHJlYWRvbmx5IHVybDogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IodXJsIDpzdHJpbmcpIHtcbiAgICAgICAgdGhpcy51cmwgPSB1cmw7XG4gICAgfVxuXG4gICAgYXN5bmMgbm90aWZ5KHRleHQ6IHN0cmluZykge1xuICAgICAgICB0cnkge1xuICAgICAgICAgICAgY29uc29sZS5pbmZvKCdtZXRob2Q9bm90aWZ5IE5vdGlmeWluZyBTbGFjaycpO1xuICAgICAgICAgICAgYXdhaXQgYXhpb3MucG9zdCh0aGlzLnVybCwge1xuICAgICAgICAgICAgICAgIHRleHQsXG4gICAgICAgICAgICB9KTtcbiAgICAgICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgIGNvbnNvbGUuZXJyb3IoJ21ldGhvZD1ub3RpZnkgU2xhY2sgbm90aWZ5IGZhaWxlZCEnKTtcbiAgICAgICAgfVxuICAgIH1cblxufVxuIl19

package/utils/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Check if arrays have only elements that also exists also in other array.
+ * Individual element count doesn't matter.
+ * Function works only for primitive types and for other it just checks the reference to object.
+ *
+ * Some examples
+ * bothArraysHasSameValues( [a, b], [b, a] )    => true
+ * bothArraysHasSameValues( [a, a], [a, a, a] ) => true
+ * bothArraysHasSameValues( [a, b], [a] )       => false
+ *
+ * Object references:
+ * const o1 = { a: 1, b: 2};
+ * const o2 = { a: 1, b: 2};
+ * // Arrays has references to same objects
+ * bothArraysHasSameValues([o1], [o1]))         => true
+ * Arrays have references to different objects
+ * bothArraysHasSameValues([o1], [o2]))         => false
+ *
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+export declare function bothArraysHasSameValues(a: null | undefined | unknown[], b: null | undefined | unknown[]): boolean;

package/utils/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bothArraysHasSameValues = void 0;
+/**
+ * Check if arrays have only elements that also exists also in other array.
+ * Individual element count doesn't matter.
+ * Function works only for primitive types and for other it just checks the reference to object.
+ *
+ * Some examples
+ * bothArraysHasSameValues( [a, b], [b, a] )    => true
+ * bothArraysHasSameValues( [a, a], [a, a, a] ) => true
+ * bothArraysHasSameValues( [a, b], [a] )       => false
+ *
+ * Object references:
+ * const o1 = { a: 1, b: 2};
+ * const o2 = { a: 1, b: 2};
+ * // Arrays has references to same objects
+ * bothArraysHasSameValues([o1], [o1]))         => true
+ * Arrays have references to different objects
+ * bothArraysHasSameValues([o1], [o2]))         => false
+ *
+ * @param a first array to compare
+ * @param b second array to compare
+ */
+function bothArraysHasSameValues(a, b) {
+    if ((a && !b) || (!a && b)) {
+        return false;
+    }
+    else if (!a && !b) {
+        return true;
+    }
+    const aSet = new Set(a);
+    const bSet = new Set(b);
+    if (aSet.size !== bSet.size) {
+        return false;
+    }
+    return Array.from(aSet).every(value => bSet.has(value));
+}
+exports.bothArraysHasSameValues = bothArraysHasSameValues;
+//# sourceMappingURL=data:application/json;base64,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