@dronedeploy/rocos-js-sdk 3.0.1-alpha.9 → 3.0.2

package/esm/services/SpotProvisioningService.d.ts

@@ -1,7 +1,7 @@
 import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { Timezone } from '../constants/timezones';
-type SpotImageTag = 'stable' | 'dev' | 'unstable';
+type SpotImageTag = 'stable' | 'dev' | 'unstable' | 'rc' | (string & {});
 export declare class SpotProvisioningService extends BaseServiceAbstract implements IBaseService {
     constructor(config: IRocosSDKConfig);
     getStatus(): boolean;

package/esm/services/SpotProvisioningServiceNode.d.ts

@@ -2,7 +2,7 @@
 import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { Timezone } from '../constants/timezones';
-type SpotImageTag = 'stable' | 'dev' | 'unstable';
+type SpotImageTag = 'stable' | 'dev' | 'unstable' | 'rc' | (string & {});
 export declare class SpotProvisioningServiceNode extends BaseServiceAbstract implements IBaseService {
     constructor(config: IRocosSDKConfig);
     getStatus(): boolean;

package/esm/services/TargetService.d.ts

@@ -0,0 +1,17 @@
+import { Asset, IBaseService, IRocosSDKConfig, RocosError, Target, TargetMedia } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+/**
+ * Service for managing targets (such as assets, PoI's, or FLOCS) on DroneDeploy
+ */
+export declare class TargetService extends BaseServiceAbstract implements IBaseService {
+    list: (projectId: string, frameID?: string) => Promise<Target[]>;
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    createTargets(projectId: string, targets: Target[]): Promise<void>;
+    listTargets(projectId: string, frameID?: string): Promise<Target[]>;
+    createAssets(projectId: string, assets: Asset[]): Promise<void>;
+    listAssets(projectId: string, frameID?: string): Promise<Asset[]>;
+    deleteAssets(projectId: string, assetIds: string[]): Promise<void>;
+    addMedia(projectId: string, targetId: string, media: TargetMedia): Promise<void>;
+}

package/esm/services/TargetService.js

@@ -0,0 +1,62 @@
+import { API_GRAPHS_ASSETS_UPLOAD_URL, API_GRAPHS_ASSETS_URL, API_GRAPHS_TARGETS_URL, API_GRAPHS_TARGET_UPLOAD_URL, } from '../constants/api';
+import { RocosError, errorCodes } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+/**
+ * Service for managing targets (such as assets, PoI's, or FLOCS) on DroneDeploy
+ */
+export class TargetService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`TargetService(${this.config.url})`);
+        this.list = this.listTargets;
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.TARGET_SERVICE_ERROR);
+    }
+    async createTargets(projectId, targets) {
+        return this.callPut(formatServiceUrl(API_GRAPHS_TARGET_UPLOAD_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), targets, `Failed to upload targets for ${projectId}`);
+    }
+    async listTargets(projectId, frameID = 'seed') {
+        const resp = await this.callGet(formatServiceUrl(API_GRAPHS_TARGETS_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), 'Failed to list targets', { frameID });
+        return resp;
+    }
+    async createAssets(projectId, assets) {
+        return this.callPut(formatServiceUrl(API_GRAPHS_ASSETS_UPLOAD_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), assets, `Failed to upload assets for ${projectId}`);
+    }
+    async listAssets(projectId, frameID = 'seed') {
+        const resp = await this.callGet(formatServiceUrl(API_GRAPHS_ASSETS_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), 'Failed to list assets', { frameID });
+        return resp;
+    }
+    async deleteAssets(projectId, assetIds) {
+        await this.callDelete(formatServiceUrl(API_GRAPHS_ASSETS_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), 'Failed to delete assets', {
+            assetIds,
+        });
+    }
+    async addMedia(projectId, targetId, media) {
+        await this.callPost(formatServiceUrl(API_GRAPHS_TARGETS_URL, {
+            url: this.config.url,
+            projectId,
+            targetId,
+        }, this.config.insecure), media, 'Failed to add media to a target');
+    }
+}

package/esm/services/TelemetryService.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { CallsignStatus, IRocosSDKConfig, IRocosTelemetryMessage, IStreamStatusMessage, ITelemetryStream, ITelemetryStreamConfig, ITelemetrySubscriptionParams, ITelemetrySubscriptions } from '../models';
+import { CallsignStatus, IRocosSDKConfig, IRocosTelemetryMessage, IStreamStatusMessage, ITelemetryStream, ITelemetryStreamConfig, ITelemetrySubscriptionParams, ITelemetrySubscriptions, TelemetryMonitorStatus } from '../models';
 import { BaseStreamService } from './BaseStreamService';
 export declare class TelemetryService extends BaseStreamService<ITelemetryStream, ITelemetryStreamConfig> {
     private statusSubscription;
@@ -34,6 +34,15 @@ export declare class TelemetryService extends BaseStreamService<ITelemetryStream
      * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
      */
     getRobotStatusChanges(projectId: string, callsign: string, heartbeatTimeoutMs?: number, intervalMs?: number): Observable<CallsignStatus>;
+    /**
+     * Subscribes to the given telemetry and checks we receive one at least emission every `heartbeatTimeoutMs` (default 5s)
+     * @param projectId
+     * @param callsign
+     * @param source the telemetry source to monitor
+     * @param heartbeatTimeoutMs optionally override the deadline for telemetry emissions (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for telemetry emissions (in ms). Default 2000ms
+     */
+    monitorTelemetryWithTimeout(projectId: string, callsign: string, source: string, heartbeatTimeoutMs?: number, intervalMs?: number): Observable<TelemetryMonitorStatus>;
     protected initStream(stream: ITelemetryStream): Promise<void>;
     private buildScope;
     private createStream;

package/esm/services/TelemetryService.js

@@ -1,5 +1,5 @@
 import { BehaviorSubject, catchError, combineLatest, distinctUntilChanged, from, interval, map, mergeAll, of, startWith, } from 'rxjs';
-import { CallsignStatus, CallsignsLookup, CallsignsLookupType, RocosError, SubscriberStatusEnum, errorCodes, } from '../models';
+import { CallsignStatus, CallsignsLookup, CallsignsLookupType, RocosError, TelemetryMonitorStatus, SubscriberStatusEnum, errorCodes, } from '../models';
 import { filter, finalize } from 'rxjs/operators';
 import { BaseStreamService } from './BaseStreamService';
 import { IDENTIFIER_NAME_TELEMETRY } from '../constants/identifier';
@@ -95,23 +95,45 @@ export class TelemetryService extends BaseStreamService {
      * @param intervalMs optionally override the interval to check for heartbeats (in ms). Default 2000ms
      */
     getRobotStatusChanges(projectId, callsign, heartbeatTimeoutMs = HEARTBEAT_TIMEOUT, intervalMs = 2000) {
+        return this.monitorTelemetryWithTimeout(projectId, callsign, HEARTBEAT_SOURCE, heartbeatTimeoutMs, intervalMs).pipe(map((status) => {
+            switch (status) {
+                case TelemetryMonitorStatus.CONNECTED:
+                    return CallsignStatus.ONLINE;
+                case TelemetryMonitorStatus.DISCONNECTED:
+                    return CallsignStatus.OFFLINE;
+                case TelemetryMonitorStatus.ERROR:
+                    return CallsignStatus.ERROR;
+                default:
+                    return CallsignStatus.UNKNOWN;
+            }
+        }));
+    }
+    /**
+     * Subscribes to the given telemetry and checks we receive one at least emission every `heartbeatTimeoutMs` (default 5s)
+     * @param projectId
+     * @param callsign
+     * @param source the telemetry source to monitor
+     * @param heartbeatTimeoutMs optionally override the deadline for telemetry emissions (in ms). Default 5000ms
+     * @param intervalMs optionally override the interval to check for telemetry emissions (in ms). Default 2000ms
+     */
+    monitorTelemetryWithTimeout(projectId, callsign, source, heartbeatTimeoutMs = HEARTBEAT_TIMEOUT, intervalMs = 2000) {
         const startedAt = Date.now();
         const heartbeatTime$ = this.subscribe({
             projectId,
-            sources: [HEARTBEAT_SOURCE],
+            sources: [source],
             callsigns: [callsign],
         }).pipe(map(() => Date.now()));
         return combineLatest([heartbeatTime$.pipe(startWith(startedAt)), interval(intervalMs)]).pipe(map(([lastHeartbeat, _]) => {
             const now = Date.now();
             // If we haven't received a heartbeat, but we've only just started
             if (lastHeartbeat === startedAt && now - startedAt <= heartbeatTimeoutMs) {
-                return CallsignStatus.UNKNOWN;
+                return TelemetryMonitorStatus.UNKNOWN;
             }
             if (now - lastHeartbeat > heartbeatTimeoutMs) {
-                return CallsignStatus.OFFLINE;
+                return TelemetryMonitorStatus.DISCONNECTED;
             }
-            return CallsignStatus.ONLINE;
-        }), startWith(CallsignStatus.UNKNOWN), distinctUntilChanged(), catchError(() => of(CallsignStatus.ERROR)));
+            return TelemetryMonitorStatus.CONNECTED;
+        }), startWith(TelemetryMonitorStatus.UNKNOWN), distinctUntilChanged(), catchError(() => of(TelemetryMonitorStatus.ERROR)));
     }
     async initStream(stream) {
         await super.initStream(stream);

package/esm/services/WorkflowService.d.ts

@@ -36,27 +36,37 @@ export declare class WorkflowService extends BaseServiceAbstract implements IBas
      */
     update(projectId: string, workflowId: string, model: Workflow): Promise<Workflow>;
     /**
-     * Upload workflow asset
+     * Delete a workflow
      *
      * @param projectId - Project Id
      * @param workflowId - Workflow Id
-     * @param fileName - Name of file including extension
-     * @param arrayBuffer - data to upload
      */
-    uploadAsset(projectId: string, workflowId: string, fileName: string, arrayBuffer: ArrayBuffer): Promise<void>;
-    protected uploadAssetWithHash(projectId: string, workflowId: string, fileName: string, arrayBuffer: ArrayBuffer, hash: string): Promise<void>;
+    delete(projectId: string, workflowId: string): Promise<void>;
     /**
-     * Delete a workflow
+     * Upload workflow asset
      *
      * @param projectId - Project Id
      * @param workflowId - Workflow Id
+     * @param fileName - Name of file including extension
+     * @param arrayBuffer - data to upload
      */
-    delete(projectId: string, workflowId: string): Promise<void>;
+    uploadAsset(projectId: string, workflowId: string, fileName: string, arrayBuffer: ArrayBuffer): Promise<void>;
+    protected uploadAssetWithHash(projectId: string, workflowId: string, fileName: string, arrayBuffer: ArrayBuffer, hash: string): Promise<void>;
     /**
      * Get deployed workflows on robot
      *
      * @param projectId - Project Id
      * @param callsign - Robot callsign
      */
-    getDeployedWorkflows(projectId: string, callsign: string): Promise<Workflow[]>;
+    getDeployedWorkflows(projectId: string, profileId: string, callsign?: string): Promise<Workflow[]>;
+    addRobotDeployment(projectId: string, callsign: string, workflowId: string): Promise<void>;
+    addProfileDeployment(projectId: string, profileId: string, workflowId: string): Promise<void>;
+    removeRobotDeployment(projectId: string, callsign: string, workflowId: string): Promise<void>;
+    removeProfileDeployment(projectId: string, profileId: string, workflowId: string): Promise<void>;
+    updateRobotDeployments(projectId: string, callsign: string, workflows: string[]): Promise<void>;
+    updateProfileDeployments(projectId: string, profileId: string, workflows: string[]): Promise<void>;
+    getAffectedRobots(projectId: string, workflowId: string): Promise<{
+        callsigns: string[];
+        profileIds: string[];
+    }>;
 }

package/esm/services/WorkflowService.js

@@ -1,4 +1,4 @@
-import { API_PROJECT_DEPLOYED_WORKFLOW_URL, API_PROJECT_WORKFLOW_ASSET_URL, API_PROJECT_WORKFLOW_ID_URL, API_PROJECT_WORKFLOW_URL, } from '../constants/api';
+import { API_PROJECT_PROFILE_DEPLOYED_WORKFLOW_URL, API_PROJECT_PROFILE_DEPLOYMENTS_URL, API_PROJECT_ROBOT_DEPLOYED_WORKFLOW_URL, API_PROJECT_ROBOT_DEPLOYMENTS_URL, API_PROJECT_ROBOT_NO_PROFILE_DEPLOYMENTS_URL, API_PROJECT_WORKFLOW_AFFECTED_URL, API_PROJECT_WORKFLOW_ASSET_URL, API_PROJECT_WORKFLOW_ID_URL, API_PROJECT_WORKFLOW_URL, } from '../constants/api';
 import { RocosError, errorCodes } from '../models/RocosError';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { RocosLogger } from '../logger/RocosLogger';
@@ -51,6 +51,16 @@ export class WorkflowService extends BaseServiceAbstract {
     async update(projectId, workflowId, model) {
         return this.callPut(formatServiceUrl(API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), model, `Failed to update workflow for ${projectId}, workflowId ${workflowId}.`);
     }
+    /**
+     * Delete a workflow
+     *
+     * @param projectId - Project Id
+     * @param workflowId - Workflow Id
+     */
+    async delete(projectId, workflowId) {
+        return this.callDelete(formatServiceUrl(API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), `Failed to delete workflow for ${projectId}, workflowId ${workflowId}.`);
+    }
+    // Assets
     /**
      * Upload workflow asset
      *
@@ -82,22 +92,38 @@ export class WorkflowService extends BaseServiceAbstract {
         if (uploadResponse.status !== 200)
             throw new Error(`Failed to upload file: ${uploadResponse.statusText}`);
     }
-    /**
-     * Delete a workflow
-     *
-     * @param projectId - Project Id
-     * @param workflowId - Workflow Id
-     */
-    async delete(projectId, workflowId) {
-        return this.callDelete(formatServiceUrl(API_PROJECT_WORKFLOW_ID_URL, { url: this.config.url, projectId, workflowId }, this.config.insecure), `Failed to delete workflow for ${projectId}, workflowId ${workflowId}.`);
-    }
+    // Deployments
     /**
      * Get deployed workflows on robot
      *
      * @param projectId - Project Id
      * @param callsign - Robot callsign
      */
-    async getDeployedWorkflows(projectId, callsign) {
-        return this.callGet(formatServiceUrl(API_PROJECT_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to update workflows for ${projectId}, callsign ${callsign}.`);
+    async getDeployedWorkflows(projectId, profileId, callsign) {
+        if (callsign) {
+            return this.callGet(formatServiceUrl(API_PROJECT_ROBOT_DEPLOYMENTS_URL, { url: this.config.url, projectId, profileId, callsign }, this.config.insecure), `Failed to get workflows for project ${projectId}, profile ${profileId}, callsign ${callsign}.`);
+        }
+        return this.callGet(formatServiceUrl(API_PROJECT_PROFILE_DEPLOYMENTS_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), `Failed to get workflows for project ${projectId}, profile ${profileId}.`);
+    }
+    async addRobotDeployment(projectId, callsign, workflowId) {
+        return this.callPost(formatServiceUrl(API_PROJECT_ROBOT_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, callsign, workflowId }, this.config.insecure), undefined, `Failed to add workflow for ${projectId}, callsign ${callsign}.`);
+    }
+    async addProfileDeployment(projectId, profileId, workflowId) {
+        return this.callPost(formatServiceUrl(API_PROJECT_PROFILE_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, profileId, workflowId }, this.config.insecure), undefined, `Failed to add workflow for ${projectId}, profile ${profileId}.`);
+    }
+    async removeRobotDeployment(projectId, callsign, workflowId) {
+        return this.callDelete(formatServiceUrl(API_PROJECT_ROBOT_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, callsign, workflowId }, this.config.insecure), `Failed to remove workflow for ${projectId}, callsign ${callsign}.`);
+    }
+    async removeProfileDeployment(projectId, profileId, workflowId) {
+        return this.callDelete(formatServiceUrl(API_PROJECT_PROFILE_DEPLOYED_WORKFLOW_URL, { url: this.config.url, projectId, profileId, workflowId }, this.config.insecure), `Failed to remove workflow for ${projectId}, profile ${profileId}.`);
+    }
+    async updateRobotDeployments(projectId, callsign, workflows) {
+        return this.callPost(formatServiceUrl(API_PROJECT_ROBOT_NO_PROFILE_DEPLOYMENTS_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), { deployed: workflows }, `Failed to update workflows for ${projectId}, callsign ${callsign}.`);
+    }
+    async updateProfileDeployments(projectId, profileId, workflows) {
+        return this.callPost(formatServiceUrl(API_PROJECT_PROFILE_DEPLOYMENTS_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), { deployed: workflows }, `Failed to update workflows for ${projectId}, profile ${profileId}.`);
+    }
+    async getAffectedRobots(projectId, workflowId) {
+        return this.callGet(formatServiceUrl(API_PROJECT_WORKFLOW_AFFECTED_URL, { url: this.config.url, projectId, workflowId, flowId: workflowId }, this.config.insecure), `Failed to get affected robots for ${projectId}, workflowId ${workflowId}.`);
     }
 }

package/esm/services/index.d.ts

@@ -5,24 +5,26 @@ export * from './CommandService';
 export * from './ConfigGroupService';
 export * from './ControlService';
 export * from './DashboardService';
+export * from './DeviceCredentialsService';
+export * from './EnvironmentService';
+export * from './EvaluatorService';
 export * from './EventService';
 export * from './FileAccessorService';
-export * from './FunctionService';
 export * from './IntegrationService';
+export * from './MapService';
+export * from './PlatformTimeService';
 export * from './ProfileService';
 export * from './ProjectService';
+export * from './RTPWebRTCService';
 export * from './RobotService';
+export * from './ScheduleService';
 export * from './SearchService';
+export * from './SpotProvisioningService';
+export * from './SpotProvisioningServiceNode';
 export * from './StreamService';
+export * from './TargetService';
 export * from './TelemetryService';
+export * from './TimeSyncerService';
 export * from './UserService';
 export * from './WebRTCSignallingService';
 export * from './WorkflowService';
-export * from './ScheduleService';
-export * from './TimeSyncerService';
-export * from './PlatformTimeService';
-export * from './SpotProvisioningService';
-export * from './SpotProvisioningServiceNode';
-export * from './MapService';
-export * from './EvaluatorService';
-export * from './RTPWebRTCService';

package/esm/services/index.js

@@ -5,24 +5,26 @@ export * from './CommandService';
 export * from './ConfigGroupService';
 export * from './ControlService';
 export * from './DashboardService';
+export * from './DeviceCredentialsService';
+export * from './EnvironmentService';
+export * from './EvaluatorService';
 export * from './EventService';
 export * from './FileAccessorService';
-export * from './FunctionService';
 export * from './IntegrationService';
+export * from './MapService';
+export * from './PlatformTimeService';
 export * from './ProfileService';
 export * from './ProjectService';
+export * from './RTPWebRTCService';
 export * from './RobotService';
+export * from './ScheduleService';
 export * from './SearchService';
+export * from './SpotProvisioningService';
+export * from './SpotProvisioningServiceNode';
 export * from './StreamService';
+export * from './TargetService';
 export * from './TelemetryService';
+export * from './TimeSyncerService';
 export * from './UserService';
 export * from './WebRTCSignallingService';
 export * from './WorkflowService';
-export * from './ScheduleService';
-export * from './TimeSyncerService';
-export * from './PlatformTimeService';
-export * from './SpotProvisioningService';
-export * from './SpotProvisioningServiceNode';
-export * from './MapService';
-export * from './EvaluatorService';
-export * from './RTPWebRTCService';

package/esm/store/RocosStore.d.ts

@@ -1,6 +1,5 @@
-import { IRocosChangeMessage } from '../models/message/IRocosChangeMessage';
+import { IRocosChangeMessage, IRocosSDKConfig } from '../models';
 import { IRocosSDK } from '../IRocosSDK';
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
 import { Subject } from 'rxjs';
 export declare class RocosStore {
     private static changeSubject$?;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.0.1-alpha.9",
+  "version": "3.0.2",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -23,11 +23,11 @@
   "devDependencies": {},
   "dependencies": {
     "@grpc/grpc-js": "^1.7.1",
-    "@improbable-eng/grpc-web": "^0.14.0",
     "@protobuf-ts/grpcweb-transport": "^2.9.1",
     "@protobuf-ts/plugin": "^2.9.1",
     "@protobuf-ts/runtime": "^2.9.1",
     "@types/json-schema": "^7.0.14",
+    "acorn": "^8.11.3",
     "buffer": "^6.0.3",
     "loglevel": "^1.7.1",
     "loglevel-plugin-prefix": "^0.8.4",

package/cjs/helpers/cleanObject.spec.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cleanObject_1 = require("./cleanObject");
-describe('cleanObject', () => {
-    const testObject = {
-        test1: 'test1',
-        test2: 'test2',
-        test3: () => 'test3',
-        test4: {
-            test1: 'test1.1',
-            test5: 'test5',
-            test6: {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            test8: () => 'test8',
-        },
-        test9: ['test9.1', 'test9.2', () => 'test8'],
-        test10: [
-            {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            {
-                test8: () => 'test8',
-            },
-        ],
-    };
-    it('should clean object to values only', () => {
-        const newObject = (0, cleanObject_1.cleanObject)(testObject);
-        expect(newObject?.test3).toBeUndefined();
-        expect(newObject?.test4?.test8).toBeUndefined();
-        expect(newObject?.test4?.test6?.test8).toBeUndefined();
-        expect(newObject?.test4?.test5).toEqual('test5');
-        expect(newObject?.test5).toBeUndefined();
-        expect(newObject?.test4?.test6?.test1).toEqual('test1.2');
-        expect(newObject?.test4?.test6?.test2).toEqual('test2.1');
-        expect(newObject?.test1).toEqual('test1');
-        expect(newObject?.test2).toEqual('test2');
-        expect(newObject?.test9).toEqual(expect.arrayContaining(['test9.1', 'test9.2']));
-        expect(newObject?.test9).toEqual(expect.not.arrayContaining([() => 'test8']));
-        expect(newObject?.test10).toEqual(expect.arrayContaining([
-            {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-            },
-            {},
-        ]));
-    });
-});

package/cjs/helpers/flattenObject.spec.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const flattenObject_1 = require("./flattenObject");
-describe('flattenObject', () => {
-    const testObject = {
-        test1: 'test1',
-        test2: 'test2',
-        test3: () => 'test3',
-        test4: {
-            test1: 'test1.1',
-            test5: 'test5',
-            test6: {
-                test7: 'test7',
-                test1: 'test1.2',
-                test2: 'test2.1',
-                test8: () => 'test8',
-            },
-            test8: () => 'test8',
-        },
-    };
-    it('should flatten object to a single level', () => {
-        const newObject = (0, flattenObject_1.flattenObject)(testObject);
-        expect(newObject?.test3).toBeUndefined();
-        expect(newObject?.test4?.test8).toBeUndefined();
-        expect(newObject?.test4?.test6?.test8).toBeUndefined();
-        expect(newObject?.test4?.test5).toBeUndefined();
-        expect(newObject?.test5).toEqual('test5');
-        expect(newObject?.test1).toEqual('test1.2');
-        expect(newObject?.test2).toEqual('test2.1');
-    });
-});

package/cjs/helpers/flattenOneOf.spec.js

@@ -1,159 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const flattenOneOf_1 = require("./flattenOneOf");
-describe('flattenOneOf', () => {
-    describe('hasOneOfField', () => {
-        it('should return false for non-object', () => {
-            expect((0, flattenOneOf_1.hasOneOfField)(null)).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)(undefined)).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)(1)).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)('')).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)(true)).toBe(false);
-        });
-        it('should return false for null content', () => {
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: null })).toBe(false);
-        });
-        it('should return false for non-object content', () => {
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: 1 })).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: '' })).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: true })).toBe(false);
-        });
-        it('should return false for non-string oneofKind', () => {
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: 1 } })).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: null } })).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: true } })).toBe(false);
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: {} } })).toBe(false);
-        });
-        it('should return true for valid oneOfField', () => {
-            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: 'test' } })).toBe(true);
-        });
-    });
-    describe('flattenOneOf', () => {
-        it('should flatten a simple oneof type', () => {
-            const a = {
-                a: 'a',
-                content: {
-                    oneofKind: 'b',
-                    b: true,
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a)).toEqual({
-                a: 'a',
-                b: true,
-            });
-        });
-        it('should flatten a nested oneof type, one level only', () => {
-            const a = {
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                content: {
-                    oneofKind: 'd',
-                    d: {
-                        content: {
-                            oneofKind: 'e',
-                            e: 5,
-                        },
-                    },
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a)).toEqual({
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                d: {
-                    content: {
-                        oneofKind: 'e',
-                        e: 5,
-                    },
-                },
-            });
-        });
-        it('should flatten to undefined if the referenced property does not exist', () => {
-            const a = {
-                content: {
-                    oneofKind: 'b',
-                    c: true,
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a)).toEqual({
-                b: undefined,
-            });
-        });
-        it('should return the original object if it does not have a oneof field', () => {
-            const a = {
-                a: 'a',
-                b: 'b',
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a)).toEqual(a);
-        });
-    });
-    describe('flattenOneOf - deep', () => {
-        it('should flatten a simple oneof type', () => {
-            const a = {
-                a: 'a',
-                content: {
-                    oneofKind: 'b',
-                    b: {
-                        d: 4,
-                    },
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a, true)).toEqual({
-                a: 'a',
-                b: { d: 4 },
-            });
-        });
-        it('should flatten a nested oneof type, all levels', () => {
-            const a = {
-                b: {
-                    content: {
-                        oneofKind: 'c',
-                        c: true,
-                    },
-                },
-                content: {
-                    oneofKind: 'd',
-                    d: {
-                        content: {
-                            oneofKind: 'e',
-                            e: 5,
-                        },
-                    },
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a, true)).toEqual({
-                b: {
-                    c: true,
-                },
-                d: {
-                    e: 5,
-                },
-            });
-        });
-        it('should flatten to undefined if the referenced property does not exist', () => {
-            const a = {
-                content: {
-                    oneofKind: 'b',
-                    c: true,
-                },
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a, true)).toEqual({
-                b: undefined,
-            });
-        });
-        it('should return the original object if it does not have a oneof field', () => {
-            const a = {
-                a: 'a',
-                b: 'b',
-            };
-            expect((0, flattenOneOf_1.flattenOneOf)(a, true)).toEqual(a);
-        });
-    });
-});