@ohos-ports/drivelist 12.0.2-beta.1

package/lib/lsblk/pairs.ts

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2018 Balena.io
+ *
+ * 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.
+ */
+
+import { getPartitionTableType } from '.';
+import { Drive, Mountpoint } from '..';
+
+interface Dict<T> {
+	[K: string]: T;
+}
+
+function parseLsblkLine(line: string): Dict<string> {
+	const data: Dict<string> = {};
+	let offset = 0;
+	let key = '';
+	let value = '';
+
+	const keyChar = /[^"=]/;
+	const whitespace = /\s+/;
+	const escape = '\\';
+	let state = 'key';
+
+	while (offset < line.length) {
+		if (state === 'key') {
+			while (keyChar.test(line[offset])) {
+				key += line[offset];
+				offset += 1;
+			}
+			if (line[offset] === '=') {
+				state = 'value';
+				offset += 1;
+			}
+		} else if (state === 'value') {
+			if (line[offset] !== '"') {
+				throw new Error(`Expected '"', saw "${line[offset]}"`);
+			}
+			offset += 1;
+			while (
+				line[offset - 1] === escape ||
+				(line[offset - 1] !== escape && line[offset] !== '"')
+			) {
+				value += line[offset];
+				offset += 1;
+			}
+			if (line[offset] !== '"') {
+				throw new Error(`Expected '"', saw "${line[offset]}"`);
+			}
+			offset += 1;
+			data[key.toLowerCase()] = value.trim();
+			key = '';
+			value = '';
+			state = 'space';
+		} else if (state === 'space') {
+			while (whitespace.test(line[offset])) {
+				offset += 1;
+			}
+			state = 'key';
+		} else {
+			throw new Error(`Undefined state "${state}"`);
+		}
+	}
+
+	return data;
+}
+
+function parseLsblk(output: string): Array<Dict<string>> {
+	return output.trim().split(/\r?\n/g).map(parseLsblkLine);
+}
+
+function consolidate(
+	devices: Array<Dict<string>>,
+): Array<Dict<string> & { mountpoints: Mountpoint[] }> {
+	const primaries = devices.filter((device) => {
+		return (
+			device.type === 'disk' &&
+			!device.name.startsWith('ram') &&
+			!device.name.startsWith('sr')
+		);
+	});
+
+	return primaries.map((device) => {
+		const children = devices.filter((child) => {
+			return (
+				['disk', 'part'].includes(child.type) &&
+				child.name.startsWith(device.name)
+			);
+		});
+		return Object.assign({}, device, {
+			mountpoints: children
+				.filter((child) => child.mountpoint)
+				.map(
+					(child): Mountpoint => {
+						return {
+							path: child.mountpoint,
+							label: child.label,
+						};
+					},
+				),
+		});
+	});
+}
+
+function getDescription(
+	device: Dict<string> & { mountpoints: Mountpoint[] },
+): string {
+	const description = [
+		device.label || '',
+		device.vendor || '',
+		device.model || '',
+	];
+	if (device.mountpoints.length) {
+		let subLabels = device.mountpoints
+			.filter((c) => {
+				return (c.label && c.label !== device.label) || c.path;
+			})
+			.map((c) => {
+				return c.label || c.path;
+			});
+		subLabels = Array.from(new Set(subLabels));
+		if (subLabels.length) {
+			description.push(`(${subLabels.join(', ')})`);
+		}
+	}
+	return description.join(' ').replace(/\s+/g, ' ').trim();
+}
+
+export function parse(stdout: string): Drive[] {
+	const devices = consolidate(parseLsblk(stdout));
+
+	return devices.map(
+		(
+			device: Dict<string> & {
+				mountpoints: Mountpoint[];
+			},
+		): Drive => {
+			const isVirtual = device.subsystems
+				? /^block$/i.test(device.subsystems)
+				: null;
+			const isSCSI = device.tran
+				? /^(?:sata|scsi|ata|ide|pci)$/i.test(device.tran)
+				: null;
+			const isUSB = device.tran ? /^usb$/i.test(device.tran) : null;
+			const isReadOnly = Number(device.ro) === 1;
+			const isRemovable =
+				Number(device.rm) === 1 ||
+				Number(device.hotplug) === 1 ||
+				Boolean(isVirtual);
+
+			return {
+				enumerator: 'lsblk:pairs',
+				busType: (device.tran || 'UNKNOWN').toUpperCase(),
+				busVersion: null,
+				device: '/dev/' + device.name,
+				devicePath: null,
+				raw: '/dev/' + device.name,
+				description: getDescription(device) || device.name,
+				error: null,
+				size: Number(device.size) || null,
+				blockSize: Number(device['phy-sec']) || 512,
+				logicalBlockSize: Number(device['log-sec']) || 512,
+				mountpoints: device.mountpoints,
+				isReadOnly,
+				isSystem: !isRemovable && !isVirtual,
+				isVirtual,
+				isRemovable,
+				isCard: null,
+				isSCSI,
+				isUSB,
+				isUAS: null,
+				partitionTableType: getPartitionTableType(
+					device.pttype as 'gpt' | 'dos' | undefined,
+				),
+			};
+		},
+	);
+}

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@ohos-ports/drivelist",
+  "version": "12.0.2-beta.1",
+  "description": "List all connected drives in your computer, in all major operating systems (OpenHarmony port)",
+  "main": "js/index.js",
+  "homepage": "https://github.com/balena-io-modules/drivelist",
+  "gypfile": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/drivelist/12.0.2"
+  },
+  "keywords": [
+    "disk",
+    "cross",
+    "platform",
+    "physical",
+    "drive",
+    "list"
+  ],
+  "directories": {
+    "test": "tests"
+  },
+  "scripts": {
+    "test": "mocha -r ts-node/register tests/**/*.spec.ts -R spec",
+    "lint": "npm run lint-cpp && npm run lint-ts",
+    "lint-cpp": "cpplint --recursive src",
+    "lint-ts": "balena-lint --typescript lib tests",
+    "prettier": "balena-lint --typescript --fix lib tests",
+    "readme": "jsdoc2md --template doc/README.hbs js/index.js > README.md",
+    "build": "node-gyp rebuild && tsc",
+    "build-ts": "tsc",
+    "prepublishOnly": "npm run build-ts && npm run readme",
+    "install": "prebuild-install --runtime napi || node-gyp rebuild",
+    "rebuild": "node-gyp rebuild"
+  },
+  "author": "Juan Cruz Viotti <juan@balena.io>",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@balena/lint": "^6.2.1",
+    "@types/bindings": "^1.5.1",
+    "@types/chai": "^4.3.4",
+    "@types/mocha": "^10.0.1",
+    "@types/sinon": "^10.0.13",
+    "chai": "^4.3.7",
+    "eslint": "^8.31.0",
+    "jsdoc-to-markdown": "^8.0.0",
+    "mocha": "^10.2.0",
+    "node-gyp": "^10.0.1",
+    "prebuild": "^11.0.4",
+    "sinon": "^15.0.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "debug": "^4.3.4",
+    "node-addon-api": "^8.0.0",
+    "prebuild-install": "^7.1.1"
+  },
+  "binary": {
+    "napi_versions": [
+      8
+    ]
+  },
+  "versionist": {
+    "publishedAt": "2024-04-08T15:45:36.490Z"
+  },
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "files": [
+    "js/",
+    "lib/",
+    "src/",
+    "build/Release/*.node",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ]
+}

package/src/darwin/REDiskList.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2019 balena.io
+ * Copyright 2018 Robin Andersson <me@robinwassen.com>
+ *
+ * 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.
+ */
+
+#ifndef SRC_DARWIN_REDISKLIST_H_
+#define SRC_DARWIN_REDISKLIST_H_
+
+#import <Foundation/Foundation.h>
+
+/**
+ * Class to return a list of disks synchronously
+ * To use the class, just init an instance of it and
+ * it will populate the disks property with NSStrings
+ *
+ * @author Robin Andersson
+ */
+@interface REDiskList : NSObject
+
+/**
+ * NSArray of disks and partitions
+ * Disks are in the format disk0, disk1 etc
+ * Partitions are in the format disk0s1, disk1s1 etc
+ */
+@property(readonly) NSArray *disks;
+
+@end
+
+#endif  // SRC_DARWIN_REDISKLIST_H_

package/src/darwin/REDiskList.m

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 balena.io
+ * Copyright 2018 Robin Andersson <me@robinwassen.com>
+ *
+ * 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.
+ */
+
+#import "REDiskList.h"
+#import <DiskArbitration/DiskArbitration.h>
+
+@implementation REDiskList
+
+- (id)init {
+  self = [super init];
+
+  if (self) {
+    _disks = [[NSMutableArray alloc] init];
+    [self populateDisksBlocking];
+    [_disks sortUsingSelector:@selector(localizedCaseInsensitiveCompare:)];
+  }
+
+  return self;
+}
+
+-(void)dealloc {
+  [_disks release];
+  [super dealloc];
+}
+
+void appendDisk(DADiskRef disk, void *context) {
+  NSMutableArray *_disks = (__bridge NSMutableArray*)context;
+  const char *bsdName = DADiskGetBSDName(disk);
+  if (bsdName != nil) {
+    [_disks addObject:[NSString stringWithUTF8String:bsdName]];
+  }
+}
+
+- (void)populateDisksBlocking {
+  DASessionRef session = DASessionCreate(kCFAllocatorDefault);
+  if (session) {
+    DARegisterDiskAppearedCallback(session, NULL, appendDisk, (void*)_disks);
+    CFRunLoopRef runLoop = [[NSRunLoop currentRunLoop] getCFRunLoop];
+    DASessionScheduleWithRunLoop(session, runLoop, kCFRunLoopDefaultMode);
+    CFRunLoopStop(runLoop);
+    CFRunLoopRunInMode((CFStringRef)NSDefaultRunLoopMode, 0.05, NO);
+    DAUnregisterCallback(session, appendDisk, (void*)_disks);
+    CFRelease(session);
+  }
+}
+
+@end

package/src/darwin/list.mm

@@ -0,0 +1,185 @@
+/*
+ * Copyright 2019 balena.io
+ * Copyright 2018 Robin Andersson <me@robinwassen.com>
+ *
+ * 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.
+ */
+
+#include <napi.h>
+#include "../drivelist.hpp"
+
+#import "REDiskList.h"
+#import <Cocoa/Cocoa.h>
+#import <DiskArbitration/DiskArbitration.h>
+
+namespace Drivelist {
+  bool IsDiskPartition(NSString *disk) {
+    NSPredicate *partitionRegEx = [NSPredicate predicateWithFormat:@"SELF MATCHES %@", @"disk\\d+s\\d+"];
+    return [partitionRegEx evaluateWithObject:disk];
+  }
+
+  bool IsCard(CFDictionaryRef diskDescription) {
+    CFDictionaryRef mediaIconDict = (CFDictionaryRef)CFDictionaryGetValue(
+      diskDescription,
+      kDADiskDescriptionMediaIconKey
+    );
+    if (mediaIconDict == nil) {
+      return false;
+    }
+
+    CFStringRef iconFileNameKeyRef = CFStringCreateWithCString(NULL, "IOBundleResourceFile", kCFStringEncodingUTF8);
+    CFStringRef iconFileNameRef = (CFStringRef)CFDictionaryGetValue(mediaIconDict, iconFileNameKeyRef);
+    CFRelease(iconFileNameKeyRef);
+
+    if (iconFileNameRef == nil) {
+      return false;
+    }
+
+    // macOS 10.14.3 - External SD card reader provides `Removable.icns`, not `SD.icns`.
+    // But we can't use it to detect SD card, because external drive has `Removable.icns` as well.
+    return [(NSString *)iconFileNameRef isEqualToString:@"SD.icns"];
+  }
+
+  NSNumber *DictionaryGetNumber(CFDictionaryRef dict, const void *key) {
+    return (NSNumber*)CFDictionaryGetValue(dict, key);
+  }
+
+  DeviceDescriptor CreateDeviceDescriptorFromDiskDescription(std::string diskBsdName, CFDictionaryRef diskDescription) {
+    NSString *deviceProtocol = (NSString*)CFDictionaryGetValue(diskDescription, kDADiskDescriptionDeviceProtocolKey);
+    NSNumber *blockSize = DictionaryGetNumber(diskDescription, kDADiskDescriptionMediaBlockSizeKey);
+    bool isInternal = [DictionaryGetNumber(diskDescription, kDADiskDescriptionDeviceInternalKey) boolValue];
+    bool isRemovable = [DictionaryGetNumber(diskDescription, kDADiskDescriptionMediaRemovableKey) boolValue];
+    bool isEjectable = [DictionaryGetNumber(diskDescription, kDADiskDescriptionMediaEjectableKey) boolValue];
+
+    DeviceDescriptor device = DeviceDescriptor();
+    NSString *mediaContent = (NSString*)CFDictionaryGetValue(diskDescription, kDADiskDescriptionMediaContentKey);
+    if ([mediaContent isEqualToString:@"GUID_partition_scheme"]) {
+      device.partitionTableType = "gpt";
+    } else if ([mediaContent isEqualToString:@"FDisk_partition_scheme"]) {
+      device.partitionTableType = "mbr";
+    }
+    device.enumerator = "DiskArbitration";
+    device.busType = (deviceProtocol != nil) ? [deviceProtocol UTF8String] : "";
+    device.busVersion = "";
+    device.busVersionNull = true;
+    device.device = "/dev/" + diskBsdName;
+    NSString *devicePath = (NSString*)CFDictionaryGetValue(diskDescription, kDADiskDescriptionBusPathKey);
+    device.devicePath = (devicePath != nil) ? [devicePath UTF8String] : "";
+    device.raw = "/dev/r" + diskBsdName;
+    NSString *description = (NSString*)CFDictionaryGetValue(diskDescription, kDADiskDescriptionMediaNameKey);
+    device.description = (description != nil) ? [description UTF8String] : "";
+    device.error = "";
+    // NOTE: Not sure if kDADiskDescriptionMediaBlockSizeKey returns
+    // the physical or logical block size since both values are equal
+    // on my machine
+    //
+    // The can be checked with the following command:
+    //      diskutil info / | grep "Block Size"
+    device.blockSize = [blockSize unsignedIntValue];
+    device.logicalBlockSize = [blockSize unsignedIntValue];
+    device.size = [DictionaryGetNumber(diskDescription, kDADiskDescriptionMediaSizeKey) unsignedLongValue];
+    device.isReadOnly = ![DictionaryGetNumber(diskDescription, kDADiskDescriptionMediaWritableKey) boolValue];
+    device.isSystem = isInternal && !isRemovable;
+    device.isVirtual = ((deviceProtocol != nil) && [deviceProtocol isEqualToString:@"Virtual Interface"]);
+    device.isRemovable = isRemovable || isEjectable;
+    device.isCard = IsCard(diskDescription);
+    // NOTE(robin): Not convinced that these bus types should result
+    // in device.isSCSI = true, it is rather "not usb or sd drive" bool
+    // But the old implementation was like this so kept it this way
+    NSArray *scsiTypes = [NSArray arrayWithObjects:@"SATA", @"SCSI", @"ATA", @"IDE", @"PCI", nil];
+    device.isSCSI = ((deviceProtocol != nil) && [scsiTypes containsObject:deviceProtocol]);
+    device.isUSB = ((deviceProtocol != nil) && [deviceProtocol isEqualToString:@"USB"]);
+    device.isUAS = false;
+    device.isUASNull = true;
+
+    return device;
+  }
+
+  std::vector<DeviceDescriptor> ListStorageDevices() {
+    std::vector<DeviceDescriptor> deviceList;
+
+    DASessionRef session = DASessionCreate(kCFAllocatorDefault);
+    if (session == nil) {
+      return deviceList;
+    }
+
+    REDiskList *dl = [[REDiskList alloc] init];
+    for (NSString* diskBsdName in dl.disks) {
+      if (IsDiskPartition(diskBsdName)) {
+        continue;
+      }
+
+      std::string diskBsdNameStr = [diskBsdName UTF8String];
+      DADiskRef disk = DADiskCreateFromBSDName(kCFAllocatorDefault, session, diskBsdNameStr.c_str());
+      if (disk == nil) {
+        continue;
+      }
+
+      CFDictionaryRef diskDescription = DADiskCopyDescription(disk);
+      if (diskDescription == nil) {
+        CFRelease(disk);
+        continue;
+      }
+
+      DeviceDescriptor device = CreateDeviceDescriptorFromDiskDescription(diskBsdNameStr, diskDescription);
+      deviceList.push_back(device);
+
+      CFRelease(diskDescription);
+      CFRelease(disk);
+    }
+    [dl release];
+
+    // Add mount points
+    NSArray *volumeKeys = [NSArray arrayWithObjects:NSURLVolumeNameKey, NSURLVolumeLocalizedNameKey, nil];
+    NSArray *volumePaths = [
+      [NSFileManager defaultManager]
+      mountedVolumeURLsIncludingResourceValuesForKeys:volumeKeys
+      options:0
+    ];
+
+    for (NSURL *path in volumePaths) {
+      DADiskRef disk = DADiskCreateFromVolumePath(kCFAllocatorDefault, session, (__bridge CFURLRef)path);
+      if (disk == nil) {
+        continue;
+      }
+
+      const char *bsdnameChar = DADiskGetBSDName(disk);
+      if (bsdnameChar == nil) {
+        CFRelease(disk);
+        continue;
+      }
+
+      NSString *volumeName;
+      [path getResourceValue:&volumeName forKey:NSURLVolumeLocalizedNameKey error:nil];
+
+      std::string partitionBsdName = std::string(bsdnameChar);
+      std::string diskBsdName = partitionBsdName.substr(0, partitionBsdName.find("s", 5));
+
+      for(std::vector<int>::size_type i = 0; i != deviceList.size(); i++) {
+        DeviceDescriptor *dd = &deviceList[i];
+
+        if (dd->device == "/dev/" + diskBsdName) {
+          dd->mountpoints.push_back([[path path] UTF8String]);
+          dd->mountpointLabels.push_back([volumeName UTF8String]);
+          break;
+        }
+      }
+
+      CFRelease(disk);
+    }
+    CFRelease(session);
+
+    return deviceList;
+  }
+
+}  // namespace Drivelist

package/src/device-descriptor.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2017 balena.io
+ *
+ * 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.
+ */
+
+#include <napi.h>
+
+#include "drivelist.hpp"
+
+using Napi::Boolean;
+using Napi::Number;
+using Napi::String;
+using Napi::Value;
+
+namespace Drivelist {
+
+Napi::Object PackDriveDescriptor(Napi::Env env,
+                                 const DeviceDescriptor *instance) {
+  Napi::Object object = Napi::Object::New(env);
+
+  object.Set(String::New(env, "enumerator"),
+             String::New(env, instance->enumerator));
+
+  object.Set(String::New(env, "busType"), String::New(env, instance->busType));
+
+  Napi::Value busVersion =
+      instance->busVersionNull
+          ? (Napi::Value)env.Null()
+          : (Napi::Value)String::New(env, instance->busVersion);
+
+  object.Set(String::New(env, "busVersion"), busVersion);
+
+  object.Set(String::New(env, "device"), String::New(env, instance->device));
+
+  Napi::Value devicePath =
+      instance->devicePathNull
+          ? (Napi::Value)env.Null()
+          : (Napi::Value)String::New(env, instance->devicePath);
+
+  object.Set(String::New(env, "devicePath"), devicePath);
+
+  object.Set(String::New(env, "raw"), String::New(env, instance->raw));
+
+  object.Set(String::New(env, "description"),
+             String::New(env, instance->description));
+
+  if (instance->partitionTableType != "") {
+    object.Set(String::New(env, "partitionTableType"),
+               String::New(env, instance->partitionTableType));
+  } else {
+    object.Set(String::New(env, "partitionTableType"), env.Null());
+  }
+
+  if (instance->error != "") {
+    object.Set(String::New(env, "error"), String::New(env, instance->error));
+  } else {
+    object.Set(String::New(env, "error"), env.Null());
+  }
+
+  object.Set(String::New(env, "size"),
+             Number::New(env, static_cast<double>(instance->size)));
+
+  object.Set(String::New(env, "blockSize"),
+             Number::New(env, static_cast<double>(instance->blockSize)));
+
+  object.Set(String::New(env, "logicalBlockSize"),
+             Number::New(env, static_cast<double>(instance->logicalBlockSize)));
+
+  Napi::Object mountpoints = Napi::Array::New(env);
+
+  uint32_t index = 0;
+  for (std::string mountpointPath : instance->mountpoints) {
+    Napi::Object mountpoint = Napi::Object::New(env);
+    mountpoint.Set(String::New(env, "path"), String::New(env, mountpointPath));
+
+    if (index < instance->mountpointLabels.size()) {
+      mountpoint.Set(String::New(env, "label"),
+                     String::New(env, instance->mountpointLabels[index]));
+    }
+
+    mountpoints.Set(index, mountpoint);
+    index++;
+  }
+
+  object.Set(String::New(env, "mountpoints"), mountpoints);
+
+  object.Set(String::New(env, "isReadOnly"),
+             Boolean::New(env, instance->isReadOnly));
+
+  object.Set(String::New(env, "isSystem"),
+             Boolean::New(env, instance->isSystem));
+
+  object.Set(String::New(env, "isVirtual"),
+             Boolean::New(env, instance->isVirtual));
+
+  object.Set(String::New(env, "isRemovable"),
+             Boolean::New(env, instance->isRemovable));
+
+  object.Set(String::New(env, "isCard"), Boolean::New(env, instance->isCard));
+
+  object.Set(String::New(env, "isSCSI"), Boolean::New(env, instance->isSCSI));
+
+  object.Set(String::New(env, "isUSB"), Boolean::New(env, instance->isUSB));
+
+  Napi::Value isUAS = instance->isUASNull
+                          ? (Napi::Value)env.Null()
+                          : (Napi::Value)Boolean::New(env, instance->isUAS);
+
+  object.Set(String::New(env, "isUAS"), isUAS);
+
+  return object;
+}
+
+}  // namespace Drivelist