@celerispay/hazelcast-client 3.12.5

package/lib/proxy/topic/Message.js

@@ -0,0 +1,23 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var Message = /** @class */ (function () {
+    function Message() {
+    }
+    return Message;
+}());
+exports.Message = Message;

package/lib/proxy/topic/MessageListener.d.ts

@@ -0,0 +1,2 @@
+import { Message } from './Message';
+export declare type MessageListener<E> = (message: Message<E>) => void;

package/lib/proxy/topic/MessageListener.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/proxy/topic/ReliableTopicListenerRunner.d.ts

@@ -0,0 +1,20 @@
+import { SerializationService } from '../../serialization/SerializationService';
+import { Ringbuffer } from '../Ringbuffer';
+import { ReliableTopicMessage } from './ReliableTopicMessage';
+import { ReliableTopicProxy } from './ReliableTopicProxy';
+import { MessageListener } from './MessageListener';
+import { ILogger } from '../../logging/ILogger';
+export declare class ReliableTopicListenerRunner<E> {
+    sequenceNumber: number;
+    private listener;
+    private ringbuffer;
+    private batchSize;
+    private serializationService;
+    private cancelled;
+    private logger;
+    private proxy;
+    private listenerId;
+    constructor(listenerId: string, listener: MessageListener<E>, ringbuffer: Ringbuffer<ReliableTopicMessage>, batchSize: number, serializationService: SerializationService, logger: ILogger, proxy: ReliableTopicProxy<E>);
+    next(): void;
+    cancel(): void;
+}

package/lib/proxy/topic/ReliableTopicListenerRunner.js

@@ -0,0 +1,73 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var HazelcastError_1 = require("../../HazelcastError");
+var Message_1 = require("./Message");
+var ReliableTopicListenerRunner = /** @class */ (function () {
+    function ReliableTopicListenerRunner(listenerId, listener, ringbuffer, batchSize, serializationService, logger, proxy) {
+        this.sequenceNumber = 0;
+        this.cancelled = false;
+        this.listenerId = listenerId;
+        this.listener = listener;
+        this.ringbuffer = ringbuffer;
+        this.batchSize = batchSize;
+        this.serializationService = serializationService;
+        this.proxy = proxy;
+        this.logger = logger;
+    }
+    ReliableTopicListenerRunner.prototype.next = function () {
+        var _this = this;
+        if (this.cancelled) {
+            return;
+        }
+        this.ringbuffer.readMany(this.sequenceNumber, 1, this.batchSize).then(function (result) {
+            if (!_this.cancelled) {
+                for (var i = 0; i < result.size(); i++) {
+                    var msg = new Message_1.Message();
+                    var item = result.get(i);
+                    msg.messageObject = _this.serializationService.toObject(item.payload);
+                    msg.publisher = item.publisherAddress;
+                    msg.publishingTime = item.publishTime;
+                    setImmediate(_this.listener, msg);
+                    _this.sequenceNumber++;
+                }
+                setImmediate(_this.next.bind(_this));
+            }
+        }).catch(function (e) {
+            var message;
+            if (e instanceof HazelcastError_1.StaleSequenceError) {
+                _this.ringbuffer.headSequence().then(function (seq) {
+                    var newSequence = seq.toNumber();
+                    message = 'Topic "' + _this.proxy.getName() + '" ran into a stale sequence. ' +
+                        ' Jumping from old sequence ' + _this.sequenceNumber + ' to new sequence ' + newSequence;
+                    _this.logger.warn('ReliableTopicListenerRunner', message);
+                    _this.sequenceNumber = newSequence;
+                    setImmediate(_this.next.bind(_this));
+                });
+                return;
+            }
+            message = 'Listener of topic "' + _this.proxy.getName() + '" caught an exception, terminating listener. ' + e;
+            _this.logger.warn('ReliableTopicListenerRunner', message);
+            _this.proxy.removeMessageListener(_this.listenerId);
+        });
+    };
+    ReliableTopicListenerRunner.prototype.cancel = function () {
+        this.cancelled = true;
+    };
+    return ReliableTopicListenerRunner;
+}());
+exports.ReliableTopicListenerRunner = ReliableTopicListenerRunner;

package/lib/proxy/topic/ReliableTopicMessage.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="long" />
+import * as Long from 'long';
+import { Data, DataInput, DataOutput } from '../../serialization/Data';
+import { IdentifiedDataSerializable, IdentifiedDataSerializableFactory } from '../../serialization/Serializable';
+import Address = require('../../Address');
+export declare const RELIABLE_TOPIC_MESSAGE_FACTORY_ID = -18;
+export declare const RELIABLE_TOPIC_CLASS_ID = 2;
+export declare class ReliableTopicMessage implements IdentifiedDataSerializable {
+    publishTime: Long;
+    publisherAddress: Address;
+    payload: Data;
+    readData(input: DataInput): any;
+    writeData(output: DataOutput): void;
+    getFactoryId(): number;
+    getClassId(): number;
+}
+export declare class ReliableTopicMessageFactory implements IdentifiedDataSerializableFactory {
+    create(type: number): IdentifiedDataSerializable;
+}

package/lib/proxy/topic/ReliableTopicMessage.js

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELIABLE_TOPIC_MESSAGE_FACTORY_ID = -18;
+exports.RELIABLE_TOPIC_CLASS_ID = 2;
+var ReliableTopicMessage = /** @class */ (function () {
+    function ReliableTopicMessage() {
+    }
+    ReliableTopicMessage.prototype.readData = function (input) {
+        this.publishTime = input.readLong();
+        this.publisherAddress = input.readObject();
+        this.payload = input.readData();
+    };
+    ReliableTopicMessage.prototype.writeData = function (output) {
+        output.writeLong(this.publishTime);
+        output.writeObject(this.publisherAddress);
+        output.writeData(this.payload);
+    };
+    ReliableTopicMessage.prototype.getFactoryId = function () {
+        return exports.RELIABLE_TOPIC_MESSAGE_FACTORY_ID;
+    };
+    ReliableTopicMessage.prototype.getClassId = function () {
+        return exports.RELIABLE_TOPIC_CLASS_ID;
+    };
+    return ReliableTopicMessage;
+}());
+exports.ReliableTopicMessage = ReliableTopicMessage;
+var ReliableTopicMessageFactory = /** @class */ (function () {
+    function ReliableTopicMessageFactory() {
+    }
+    ReliableTopicMessageFactory.prototype.create = function (type) {
+        if (type === exports.RELIABLE_TOPIC_CLASS_ID) {
+            return new ReliableTopicMessage();
+        }
+        return null;
+    };
+    return ReliableTopicMessageFactory;
+}());
+exports.ReliableTopicMessageFactory = ReliableTopicMessageFactory;

package/lib/proxy/topic/ReliableTopicProxy.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="bluebird" />
+import * as Promise from 'bluebird';
+import HazelcastClient from '../../HazelcastClient';
+import { BaseProxy } from '../BaseProxy';
+import { Ringbuffer } from '../Ringbuffer';
+import { ITopic } from './ITopic';
+import { ReliableTopicMessage } from './ReliableTopicMessage';
+import { MessageListener } from './MessageListener';
+export declare const RINGBUFFER_PREFIX = "_hz_rb_";
+export declare const TOPIC_INITIAL_BACKOFF = 100;
+export declare const TOPIC_MAX_BACKOFF = 2000;
+export declare class ReliableTopicProxy<E> extends BaseProxy implements ITopic<E> {
+    private ringbuffer;
+    private readonly localAddress;
+    private readonly batchSize;
+    private readonly runners;
+    private readonly serializationService;
+    private readonly overloadPolicy;
+    constructor(client: HazelcastClient, serviceName: string, name: string);
+    setRingbuffer(): Promise<void>;
+    addMessageListener(listener: MessageListener<E>): string;
+    removeMessageListener(id: string): boolean;
+    publish(message: E): Promise<void>;
+    getRingbuffer(): Ringbuffer<ReliableTopicMessage>;
+    destroy(): Promise<void>;
+    private addOrDiscard(reliableTopicMessage);
+    private addWithError(reliableTopicMessage);
+    private addOrOverwrite(reliableTopicMessage);
+    private addWithBackoff(reliableTopicMessage);
+    private trySendMessage(message, delay, resolve);
+}

package/lib/proxy/topic/ReliableTopicProxy.js

@@ -0,0 +1,151 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var Promise = require("bluebird");
+var OverflowPolicy_1 = require("../../core/OverflowPolicy");
+var HazelcastError_1 = require("../../HazelcastError");
+var UuidUtil_1 = require("../../util/UuidUtil");
+var BaseProxy_1 = require("../BaseProxy");
+var ReliableTopicMessage_1 = require("./ReliableTopicMessage");
+var ReliableTopicListenerRunner_1 = require("./ReliableTopicListenerRunner");
+var TopicOverloadPolicy_1 = require("./TopicOverloadPolicy");
+var Long = require("long");
+exports.RINGBUFFER_PREFIX = '_hz_rb_';
+exports.TOPIC_INITIAL_BACKOFF = 100;
+exports.TOPIC_MAX_BACKOFF = 2000;
+var ReliableTopicProxy = /** @class */ (function (_super) {
+    __extends(ReliableTopicProxy, _super);
+    function ReliableTopicProxy(client, serviceName, name) {
+        var _this = _super.call(this, client, serviceName, name) || this;
+        _this.runners = {};
+        _this.localAddress = client.getClusterService().getClientInfo().localAddress;
+        var config = client.getConfig().getReliableTopicConfig(name);
+        _this.batchSize = config.readBatchSize;
+        _this.overloadPolicy = config.overloadPolicy;
+        _this.serializationService = client.getSerializationService();
+        _this.name = name;
+        return _this;
+    }
+    ReliableTopicProxy.prototype.setRingbuffer = function () {
+        var _this = this;
+        return this.client.getRingbuffer(exports.RINGBUFFER_PREFIX + this.name).then(function (buffer) {
+            _this.ringbuffer = buffer;
+        });
+    };
+    ReliableTopicProxy.prototype.addMessageListener = function (listener) {
+        var listenerId = UuidUtil_1.UuidUtil.generate().toString();
+        var runner = new ReliableTopicListenerRunner_1.ReliableTopicListenerRunner(listenerId, listener, this.ringbuffer, this.batchSize, this.serializationService, this.client.getLoggingService().getLogger(), this);
+        this.runners[listenerId] = runner;
+        this.ringbuffer.tailSequence().then(function (sequence) {
+            runner.sequenceNumber = sequence.toNumber() + 1;
+            runner.next();
+        });
+        return listenerId;
+    };
+    ReliableTopicProxy.prototype.removeMessageListener = function (id) {
+        var runner = this.runners[id];
+        if (!runner) {
+            return false;
+        }
+        runner.cancel();
+        delete this.runners[id];
+        return true;
+    };
+    ReliableTopicProxy.prototype.publish = function (message) {
+        var reliableTopicMessage = new ReliableTopicMessage_1.ReliableTopicMessage();
+        reliableTopicMessage.payload = this.serializationService.toData(message);
+        reliableTopicMessage.publishTime = Long.fromNumber(Date.now());
+        reliableTopicMessage.publisherAddress = this.localAddress;
+        switch (this.overloadPolicy) {
+            case TopicOverloadPolicy_1.TopicOverloadPolicy.ERROR:
+                return this.addWithError(reliableTopicMessage);
+            case TopicOverloadPolicy_1.TopicOverloadPolicy.DISCARD_NEWEST:
+                return this.addOrDiscard(reliableTopicMessage);
+            case TopicOverloadPolicy_1.TopicOverloadPolicy.DISCARD_OLDEST:
+                return this.addOrOverwrite(reliableTopicMessage);
+            case TopicOverloadPolicy_1.TopicOverloadPolicy.BLOCK:
+                return this.addWithBackoff(reliableTopicMessage);
+            default:
+                throw new RangeError('Unknown overload policy');
+        }
+    };
+    ReliableTopicProxy.prototype.getRingbuffer = function () {
+        return this.ringbuffer;
+    };
+    ReliableTopicProxy.prototype.destroy = function () {
+        for (var k in this.runners) {
+            var runner = this.runners[k];
+            runner.cancel();
+        }
+        return this.ringbuffer.destroy();
+    };
+    ReliableTopicProxy.prototype.addOrDiscard = function (reliableTopicMessage) {
+        return this.ringbuffer.add(reliableTopicMessage, OverflowPolicy_1.OverflowPolicy.FAIL).then(function () {
+            return null;
+        });
+    };
+    ReliableTopicProxy.prototype.addWithError = function (reliableTopicMessage) {
+        var _this = this;
+        return this.ringbuffer.add(reliableTopicMessage, OverflowPolicy_1.OverflowPolicy.FAIL).then(function (seq) {
+            if (seq.toNumber() === -1) {
+                throw new HazelcastError_1.TopicOverloadError('Failed to publish message: ' + reliableTopicMessage +
+                    ' on topic: ' + _this.getName());
+            }
+            return null;
+        });
+    };
+    ReliableTopicProxy.prototype.addOrOverwrite = function (reliableTopicMessage) {
+        return this.ringbuffer.add(reliableTopicMessage, OverflowPolicy_1.OverflowPolicy.OVERWRITE).then(function () {
+            return null;
+        });
+    };
+    ReliableTopicProxy.prototype.addWithBackoff = function (reliableTopicMessage) {
+        var resolve;
+        var promise = new Promise(function () {
+            resolve = arguments[0];
+        });
+        this.trySendMessage(reliableTopicMessage, exports.TOPIC_INITIAL_BACKOFF, resolve);
+        return promise;
+    };
+    ReliableTopicProxy.prototype.trySendMessage = function (message, delay, resolve) {
+        var _this = this;
+        this.ringbuffer.add(message, OverflowPolicy_1.OverflowPolicy.FAIL).then(function (seq) {
+            if (seq.toNumber() === -1) {
+                var newDelay = delay *= 2;
+                if (newDelay > exports.TOPIC_MAX_BACKOFF) {
+                    newDelay = exports.TOPIC_MAX_BACKOFF;
+                }
+                _this.trySendMessage(message, newDelay, resolve);
+            }
+            else {
+                resolve();
+            }
+        });
+    };
+    return ReliableTopicProxy;
+}(BaseProxy_1.BaseProxy));
+exports.ReliableTopicProxy = ReliableTopicProxy;

package/lib/proxy/topic/TopicOverloadPolicy.d.ts

@@ -0,0 +1,23 @@
+export declare enum TopicOverloadPolicy {
+    /**
+     * Using this policy, a message that has not expired can be overwritten.
+     * No matter the retention period set, the overwrite will just overwrite the item.
+     *
+     * This can be a problem for slow consumers because they were promised a certain time window to process messages.
+     * But it will benefit producers and fast consumers since they are able to continue.
+     * This policy sacrifices the slow producer in favor of fast producers/consumers.
+     */
+    DISCARD_OLDEST = 0,
+    /**
+     * The message that was to be published, is discarded.
+     */
+    DISCARD_NEWEST = 1,
+    /**
+     * The caller will wait till there space in the ringbuffer.
+     */
+    BLOCK = 2,
+    /**
+     * The publish call immediately fails.
+     */
+    ERROR = 3,
+}

package/lib/proxy/topic/TopicOverloadPolicy.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var TopicOverloadPolicy;
+(function (TopicOverloadPolicy) {
+    /**
+     * Using this policy, a message that has not expired can be overwritten.
+     * No matter the retention period set, the overwrite will just overwrite the item.
+     *
+     * This can be a problem for slow consumers because they were promised a certain time window to process messages.
+     * But it will benefit producers and fast consumers since they are able to continue.
+     * This policy sacrifices the slow producer in favor of fast producers/consumers.
+     */
+    TopicOverloadPolicy[TopicOverloadPolicy["DISCARD_OLDEST"] = 0] = "DISCARD_OLDEST";
+    /**
+     * The message that was to be published, is discarded.
+     */
+    TopicOverloadPolicy[TopicOverloadPolicy["DISCARD_NEWEST"] = 1] = "DISCARD_NEWEST";
+    /**
+     * The caller will wait till there space in the ringbuffer.
+     */
+    TopicOverloadPolicy[TopicOverloadPolicy["BLOCK"] = 2] = "BLOCK";
+    /**
+     * The publish call immediately fails.
+     */
+    TopicOverloadPolicy[TopicOverloadPolicy["ERROR"] = 3] = "ERROR";
+})(TopicOverloadPolicy = exports.TopicOverloadPolicy || (exports.TopicOverloadPolicy = {}));

package/lib/serialization/Data.d.ts

@@ -0,0 +1,114 @@
+/// <reference types="long" />
+import { Buffer } from 'safe-buffer';
+import * as Long from 'long';
+export interface Data {
+    /**
+     * Returns serialized representation in a buffer
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns serialization type
+     */
+    getType(): number;
+    /**
+     * Returns the total size of data in bytes
+     */
+    totalSize(): number;
+    /**
+     * Returns size of internal binary data in bytes
+     */
+    dataSize(): number;
+    /**
+     * Returns approximate heap cost of this Data object in bytes
+     */
+    getHeapCost(): number;
+    /**
+     * Returns partition hash of serialized object
+     */
+    getPartitionHash(): number;
+    /**
+     * Returns true if data has partition hash
+     */
+    hasPartitionHash(): boolean;
+    /**
+     * Returns hashcode for this data
+     */
+    hashCode(): number;
+    equals(other: Data): boolean;
+    /**
+     * Returns true if the object is a portable object
+     */
+    isPortable(): boolean;
+}
+export interface DataOutput {
+    clear(): void;
+    isBigEndian(): boolean;
+    position(newPosition?: number): number;
+    toBuffer(): Buffer;
+    write(byte: number | Buffer): void;
+    writeBoolean(val: boolean): void;
+    writeBooleanArray(val: boolean[]): void;
+    writeByte(byte: number): void;
+    writeByteArray(bytes: number[]): void;
+    writeBytes(bytes: string): void;
+    writeChar(char: string): void;
+    writeCharArray(chars: string[]): void;
+    writeChars(chars: string): void;
+    writeData(data: Data): void;
+    writeDouble(double: number): void;
+    writeDoubleArray(doubles: number[]): void;
+    writeFloat(float: number): void;
+    writeFloatArray(floats: number[]): void;
+    writeInt(int: number): void;
+    writeIntBE(int: number): void;
+    writeIntArray(ints: number[]): void;
+    writeLong(long: Long): void;
+    writeLongArray(longs: Long[]): void;
+    writeObject(object: any): void;
+    writeShort(short: number): void;
+    writeShortArray(shorts: number[]): void;
+    writeUTF(val: string): void;
+    writeUTFArray(val: string[]): void;
+    writeZeroBytes(count: number): void;
+}
+export interface PositionalDataOutput extends DataOutput {
+    pwrite(position: number, byte: number | Buffer): void;
+    pwriteBoolean(position: number, val: boolean): void;
+    pwriteByte(position: number, byte: number): void;
+    pwriteChar(position: number, char: string): void;
+    pwriteDouble(position: number, double: number): void;
+    pwriteFloat(position: number, float: number): void;
+    pwriteInt(position: number, int: number): void;
+    pwriteIntBE(position: number, int: number): void;
+    pwriteLong(position: number, long: Long): void;
+    pwriteShort(position: number, short: number): void;
+}
+export interface DataInput {
+    isBigEndian(): boolean;
+    position(newPosition?: number): number;
+    read(pos?: number): number;
+    readBoolean(pos?: number): boolean;
+    readBooleanArray(pos?: number): boolean[];
+    readByte(pos?: number): number;
+    readByteArray(pos?: number): number[];
+    readChar(pos?: number): string;
+    readCharArray(pos?: number): string[];
+    readData(pos?: number): Data;
+    readDouble(pos?: number): number;
+    readDoubleArray(pos?: number): number[];
+    readFloat(pos?: number): number;
+    readFloatArray(pos?: number): number[];
+    readInt(pos?: number): number;
+    readIntArray(pos?: number): number[];
+    readLong(pos?: number): Long;
+    readLongArray(pos?: number): Long[];
+    readObject(): any;
+    readShort(pos?: number): number;
+    readShortArray(pos?: number): number[];
+    readUnsignedByte(pos?: number): number;
+    readUnsignedShort(pos?: number): number;
+    readUTF(pos?: number): string;
+    readUTFArray(pos?: number): string[];
+    reset(): void;
+    skipBytes(count: number): void;
+}

package/lib/serialization/Data.js

@@ -0,0 +1,17 @@
+"use strict";
+/*
+ * Copyright (c) 2008-2021, Hazelcast, Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });