@vscodium/native-keymap 3.3.7-258412

package/deps/chromium/x/keysym_to_unicode.h

@@ -0,0 +1,26 @@
+// ----------------------------------------------------------------------------------------------------------------
+//
+// [13.01.2022] https://source.chromium.org/chromium/chromium/src/+/main:ui/events/keycodes/keysym_to_unicode.h
+//
+// ----------------------------------------------------------------------------------------------------------------
+
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_EVENTS_KEYCODES_KEYSYM_TO_UNICODE_H_
+#define UI_EVENTS_KEYCODES_KEYSYM_TO_UNICODE_H_
+
+#include <stdint.h>
+
+namespace ui {
+
+// Returns a Unicode character corresponding to the given |keysym|.  If the
+// |keysym| doesn't represent a printable character, returns zero.  We don't
+// support characters outside the Basic Plane, and this function returns zero
+// in that case.
+uint16_t GetUnicodeCharacterFromXKeySym(unsigned long keysym);
+
+}  // namespace ui
+
+#endif  // UI_EVENTS_KEYCODES_KEYSYM_TO_UNICODE_H_

package/index.d.ts

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface IWindowsKeyMapping {
+	vkey: string;
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+export interface IWindowsKeyboardMapping {
+	[code: string]: IWindowsKeyMapping;
+}
+export interface ILinuxKeyMapping {
+	value: string;
+	withShift: string;
+	withAltGr: string;
+	withShiftAltGr: string;
+}
+export interface ILinuxKeyboardMapping {
+	[code: string]: ILinuxKeyMapping;
+}
+export interface IMacKeyMapping {
+	value: string;
+	valueIsDeadKey: boolean;
+	withShift: string;
+	withShiftIsDeadKey: boolean;
+	withAltGr: string;
+	withAltGrIsDeadKey: boolean;
+	withShiftAltGr: string;
+	withShiftAltGrIsDeadKey: boolean;
+}
+export interface IMacKeyboardMapping {
+	[code: string]: IMacKeyMapping;
+}
+
+export type IKeyboardMapping = IWindowsKeyboardMapping | ILinuxKeyboardMapping | IMacKeyboardMapping;
+
+export function getKeyMap(): IKeyboardMapping;
+
+export interface IWindowsKeyboardLayoutInfo {
+	name: string;
+	id: string;
+	text: string;
+}
+
+export interface ILinuxKeyboardLayoutInfo {
+	model: string;
+	group: number;
+	layout: string;
+	variant: string;
+	options: string;
+	rules: string;
+}
+
+export interface IMacKeyboardLayoutInfo {
+	id: string;
+	localizedName: string;
+	lang: string;
+}
+
+export type IKeyboardLayoutInfo = IWindowsKeyboardLayoutInfo | ILinuxKeyboardLayoutInfo | IMacKeyboardLayoutInfo;
+
+export function getCurrentKeyboardLayout(): IKeyboardLayoutInfo;
+
+export function onDidChangeKeyboardLayout(callback: () => void): void;
+
+export function isISOKeyboard(): boolean | undefined;

package/index.js

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+function NativeBinding() {
+  this._tried = false;
+  this._keymapping = null;
+}
+NativeBinding.prototype._init = function() {
+  if (this._tried) {
+    return;
+  }
+  this._tried = true;
+  try {
+    this._keymapping = require('./build/Release/keymapping');
+  } catch (err) {
+    // fallback to the debug build
+    this._keymapping = require('./build/Debug/keymapping');
+  }
+};
+NativeBinding.prototype.getKeyMap = function() {
+  try {
+    this._init();
+    return this._keymapping.getKeyMap();
+  } catch(err) {
+    console.error(err);
+    return [];
+  }
+};
+NativeBinding.prototype.getCurrentKeyboardLayout = function() {
+  try {
+    this._init();
+    return this._keymapping.getCurrentKeyboardLayout();
+  } catch(err) {
+    console.error(err);
+    return null;
+  }
+};
+NativeBinding.prototype.onDidChangeKeyboardLayout = function(callback) {
+  try {
+    this._init();
+    this._keymapping.onDidChangeKeyboardLayout(callback);
+  } catch(err) {
+    console.error(err);
+  }
+}
+NativeBinding.prototype.isISOKeyboard = function(callback) {
+  try {
+    this._init();
+    return this._keymapping.isISOKeyboard();
+  } catch(err) {
+    return false;
+  }
+}
+
+var binding = new NativeBinding();
+
+exports.getCurrentKeyboardLayout = function() {
+  return binding.getCurrentKeyboardLayout();
+};
+exports.getKeyMap = function() {
+  return binding.getKeyMap();
+};
+exports.onDidChangeKeyboardLayout = function(callback) {
+  return binding.onDidChangeKeyboardLayout(callback);
+};
+exports.isISOKeyboard = function(callback) {
+  return binding.isISOKeyboard(callback);
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@vscodium/native-keymap",
+  "version": "3.3.7-258412",
+  "description": "Get OS key mapping",
+  "main": "index.js",
+  "typings": "index.d.ts",
+  "scripts": {
+    "release": "release-it --no-increment",
+    "test": "node test/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vscodium/native-keymap.git"
+  },
+  "author": "Microsoft Corporation",
+  "license": "MIT",
+  "devDependencies": {
+    "release-it": "^19.1.0"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ]
+  }
+}

package/release/native-keymap-3.3.7-258412-darwin-arm64.tar.gz.sha256

@@ -0,0 +1 @@
+b2fd9877d857f2b756bd8ac107840dd63b65e8613f8764c7af38ea200e87d2af  native-keymap-3.3.7-258412-darwin-arm64.tar.gz

package/release/native-keymap-3.3.7-258412-darwin-x64.tar.gz.sha256

@@ -0,0 +1 @@
+61e81840f9c4d1b058987807cb6762e307e34dfaac5e66df01dce513cfda8137  native-keymap-3.3.7-258412-darwin-x64.tar.gz

package/release/native-keymap-3.3.7-258412-linux-arm64.tar.gz.sha256

@@ -0,0 +1 @@
+59f5b25556c9cbbc239431138b3f6c3e21f08a8d8bba245091ec043a5297f4c7  native-keymap-3.3.7-258412-linux-arm64.tar.gz

package/release/native-keymap-3.3.7-258412-linux-armhf.tar.gz.sha256

@@ -0,0 +1 @@
+7e328bc73cc8668f5c620cf2bbc43f906a041e9274976356052fd2f7de262a1c  native-keymap-3.3.7-258412-linux-armhf.tar.gz

package/release/native-keymap-3.3.7-258412-linux-loong64.tar.gz.sha256

@@ -0,0 +1 @@
+4649674b066baebaeee2ab7affb96ead8496f12f7bbffb2f0f01c1dc4861cf3b  native-keymap-3.3.7-258412-linux-loong64.tar.gz

package/release/native-keymap-3.3.7-258412-linux-ppc64le.tar.gz.sha256

@@ -0,0 +1 @@
+aec80a65680ef54ac5711b62038d4a754f49547b69c8128354fdeb1175cfa15a  native-keymap-3.3.7-258412-linux-ppc64le.tar.gz

package/release/native-keymap-3.3.7-258412-linux-riscv64.tar.gz.sha256

@@ -0,0 +1 @@
+327ae5945d4fa49187598a9543e356bc41edf292aec559a15ba571749207cda4  native-keymap-3.3.7-258412-linux-riscv64.tar.gz

package/release/native-keymap-3.3.7-258412-linux-s390x.tar.gz.sha256

@@ -0,0 +1 @@
+04e0bb1dead00cc3d1a7fbf069d5b0b17cf08bbe0c57d2eef55b125ed6365735  native-keymap-3.3.7-258412-linux-s390x.tar.gz

package/release/native-keymap-3.3.7-258412-linux-x64.tar.gz.sha256

@@ -0,0 +1 @@
+ac2aa5136c94aed4b6fab4ad26f9fe755c4e7745e1251d24d46dc05cc9d87567  native-keymap-3.3.7-258412-linux-x64.tar.gz

package/release/native-keymap-3.3.7-258412-win32-arm64.tar.gz.sha256

@@ -0,0 +1 @@
+a73eb41dbb28d49cdcfb9d9c4d3643e4aaf9cb72f61414a7765a2f3994b6518b *native-keymap-3.3.7-258412-win32-arm64.tar.gz

package/release/native-keymap-3.3.7-258412-win32-x64.tar.gz.sha256

@@ -0,0 +1 @@
+1ccb734a7bc8d056d0b5ae8f88d9ab549cb19f12d1d4f66919e1091c2295b951 *native-keymap-3.3.7-258412-win32-x64.tar.gz

package/src/common.h

@@ -0,0 +1,92 @@
+// """
+// Copyright Node.js contributors. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+// """
+
+// Empty value so that macros here are able to return NULL or void
+#define NAPI_RETVAL_NOTHING  // Intentionally blank #define
+
+#define GET_AND_THROW_LAST_ERROR(env)                                    \
+  do {                                                                   \
+    const napi_extended_error_info *error_info;                          \
+    napi_get_last_error_info((env), &error_info);                        \
+    bool is_pending;                                                     \
+    napi_is_exception_pending((env), &is_pending);                       \
+    /* If an exception is already pending, don't rethrow it */           \
+    if (!is_pending) {                                                   \
+      const char* error_message = error_info->error_message != NULL ?    \
+        error_info->error_message :                                      \
+        "empty error message";                                           \
+      napi_throw_error((env), NULL, error_message);                      \
+    }                                                                    \
+  } while (0)
+
+#define NAPI_ASSERT_BASE(env, assertion, message, ret_val)               \
+  do {                                                                   \
+    if (!(assertion)) {                                                  \
+      napi_throw_error(                                                  \
+          (env),                                                         \
+        NULL,                                                            \
+          "assertion (" #assertion ") failed: " message);                \
+      return ret_val;                                                    \
+    }                                                                    \
+  } while (0)
+
+// Returns NULL on failed assertion.
+// This is meant to be used inside napi_callback methods.
+#define NAPI_ASSERT(env, assertion, message)                             \
+  NAPI_ASSERT_BASE(env, assertion, message, NULL)
+
+// Returns empty on failed assertion.
+// This is meant to be used inside functions with void return type.
+#define NAPI_ASSERT_RETURN_VOID(env, assertion, message)                 \
+  NAPI_ASSERT_BASE(env, assertion, message, NAPI_RETVAL_NOTHING)
+
+#define NAPI_CALL_BASE(env, the_call, ret_val)                           \
+  do {                                                                   \
+    if ((the_call) != napi_ok) {                                         \
+      GET_AND_THROW_LAST_ERROR((env));                                   \
+      return ret_val;                                                    \
+    }                                                                    \
+  } while (0)
+
+// Returns NULL if the_call doesn't return napi_ok.
+#define NAPI_CALL(env, the_call)                                         \
+  NAPI_CALL_BASE(env, the_call, NULL)
+
+// Returns empty if the_call doesn't return napi_ok.
+#define NAPI_CALL_RETURN_VOID(env, the_call)                             \
+  NAPI_CALL_BASE(env, the_call, NAPI_RETVAL_NOTHING)
+
+// Returns empty if the_call doesn't return napi_ok.
+#define NAPI_CALL_RETURN_STATUS(env, the_call)                           \
+  do {                                                                   \
+    napi_status status = (the_call);                                     \
+    if (status != napi_ok) {                                             \
+      GET_AND_THROW_LAST_ERROR((env));                                   \
+      return status;                                                     \
+    }                                                                    \
+  } while (0)
+
+#define DECLARE_NAPI_PROPERTY(name, func)                                \
+  { (name), NULL, (func), NULL, NULL, NULL, napi_default, NULL }
+
+#define DECLARE_NAPI_GETTER(name, func)                                  \
+  { (name), NULL, NULL, (func), NULL, NULL, napi_default, NULL }

package/src/keyboard_mac.mm

@@ -0,0 +1,209 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+#import <Cocoa/Cocoa.h>
+#include <Carbon/Carbon.h>
+
+#include "string_conversion.h"
+#include "keymapping.h"
+#include "common.h"
+#include "../deps/chromium/macros.h"
+
+namespace {
+
+std::pair<bool,std::string> ConvertKeyCodeToText(const UCKeyboardLayout* keyboard_layout, int mac_key_code, int modifiers) {
+
+  int mac_modifiers = 0;
+  if (modifiers & kShiftKeyModifierMask)
+    mac_modifiers |= shiftKey;
+  if (modifiers & kControlKeyModifierMask)
+    mac_modifiers |= controlKey;
+  if (modifiers & kAltKeyModifierMask)
+    mac_modifiers |= optionKey;
+  if (modifiers & kMetaKeyModifierMask)
+    mac_modifiers |= cmdKey;
+
+  // Convert EventRecord modifiers to format UCKeyTranslate accepts. See docs
+  // on UCKeyTranslate for more info.
+  UInt32 modifier_key_state = (mac_modifiers >> 8) & 0xFF;
+
+  UInt32 dead_key_state = 0;
+  UniCharCount char_count = 0;
+  UniChar character = 0;
+  OSStatus status = UCKeyTranslate(
+      keyboard_layout,
+      static_cast<UInt16>(mac_key_code),
+      kUCKeyActionDown,
+      modifier_key_state,
+      LMGetKbdLast(),
+      kUCKeyTranslateNoDeadKeysBit,
+      &dead_key_state,
+      1,
+      &char_count,
+      &character);
+
+  bool is_dead_key = false;
+  if (status == noErr && char_count == 0 && dead_key_state != 0) {
+    is_dead_key = true;
+    status = UCKeyTranslate(
+        keyboard_layout,
+        static_cast<UInt16>(mac_key_code),
+        kUCKeyActionDown,
+        modifier_key_state,
+        LMGetKbdLast(),
+        kUCKeyTranslateNoDeadKeysBit,
+        &dead_key_state,
+        1,
+        &char_count,
+        &character);
+  }
+
+  if (status == noErr && char_count == 1 && !std::iscntrl(character)) {
+    wchar_t value = character;
+    return std::make_pair(is_dead_key, vscode_keyboard::UTF16toUTF8(&value, 1));
+  }
+  return std::make_pair(false, std::string());
+}
+
+} // namespace
+
+namespace vscode_keyboard {
+
+
+#define DOM_CODE(usb, evdev, xkb, win, mac, code, id) {usb, mac, code}
+#define DOM_CODE_DECLARATION const KeycodeMapEntry usb_keycode_map[] =
+#include "../deps/chromium/dom_code_data.inc"
+#undef DOM_CODE
+#undef DOM_CODE_DECLARATION
+
+napi_value GetKeyMapImpl(napi_env env, napi_callback_info info) {
+
+  napi_value result;
+  NAPI_CALL(env, napi_create_object(env, &result));
+
+  TISInputSourceRef source = TISCopyCurrentKeyboardInputSource();
+  CFDataRef layout_data = static_cast<CFDataRef>((TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData)));
+  if (!layout_data) {
+    // TISGetInputSourceProperty returns null with  Japanese keyboard layout.
+    // Using TISCopyCurrentKeyboardLayoutInputSource to fix NULL return.
+    source = TISCopyCurrentKeyboardLayoutInputSource();
+    layout_data = static_cast<CFDataRef>((TISGetInputSourceProperty(source, kTISPropertyUnicodeKeyLayoutData)));
+    if (!layout_data) {
+      // https://developer.apple.com/library/mac/documentation/TextFonts/Reference/TextInputSourcesReference/#//apple_ref/c/func/TISGetInputSourceProperty
+      return result;
+    }
+  }
+
+  const UCKeyboardLayout* keyboard_layout = reinterpret_cast<const UCKeyboardLayout*>(CFDataGetBytePtr(layout_data));
+
+  size_t cnt = sizeof(usb_keycode_map) / sizeof(usb_keycode_map[0]);
+
+  napi_value true_value;
+  NAPI_CALL(env, napi_get_boolean(env, true, &true_value));
+
+  napi_value false_value;
+  NAPI_CALL(env, napi_get_boolean(env, false, &false_value));
+
+  for (size_t i = 0; i < cnt; ++i) {
+    const char *code = usb_keycode_map[i].code;
+    int native_keycode = usb_keycode_map[i].native_keycode;
+
+    if (!code || native_keycode >= 0xffff) {
+      continue;
+    }
+
+    napi_value entry;
+    NAPI_CALL(env, napi_create_object(env, &entry));
+
+    {
+      std::pair<bool,std::string> value = ConvertKeyCodeToText(keyboard_layout, native_keycode, 0);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "value", value.second.c_str()));
+      NAPI_CALL(env, napi_set_named_property(env, entry, "valueIsDeadKey", value.first ? true_value : false_value));
+    }
+
+    {
+      std::pair<bool,std::string> with_shift = ConvertKeyCodeToText(keyboard_layout, native_keycode, kShiftKeyModifierMask);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withShift", with_shift.second.c_str()));
+      NAPI_CALL(env, napi_set_named_property(env, entry, "withShiftIsDeadKey", with_shift.first ? true_value : false_value));
+    }
+
+    {
+      std::pair<bool,std::string> with_alt_gr = ConvertKeyCodeToText(keyboard_layout, native_keycode, kAltKeyModifierMask);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withAltGr", with_alt_gr.second.c_str()));
+      NAPI_CALL(env, napi_set_named_property(env, entry, "withAltGrIsDeadKey", with_alt_gr.first ? true_value : false_value));
+    }
+
+    {
+      std::pair<bool,std::string> with_shift_alt_gr = ConvertKeyCodeToText(keyboard_layout, native_keycode, kShiftKeyModifierMask | kAltKeyModifierMask);
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, entry, "withShiftAltGr", with_shift_alt_gr.second.c_str()));
+      NAPI_CALL(env, napi_set_named_property(env, entry, "withShiftAltGrIsDeadKey", with_shift_alt_gr.first ? true_value : false_value));
+    }
+
+    NAPI_CALL(env, napi_set_named_property(env, result, code, entry));
+  }
+  return result;
+}
+
+napi_value GetCurrentKeyboardLayoutImpl(napi_env env, napi_callback_info info) {
+
+  napi_value result;
+  NAPI_CALL(env, napi_create_object(env, &result));
+
+  TISInputSourceRef source = TISCopyCurrentKeyboardInputSource();
+  CFStringRef source_id = (CFStringRef) TISGetInputSourceProperty(source, kTISPropertyInputSourceID);
+  if(source_id) {
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "id", std::string([(NSString *)source_id UTF8String]).c_str()));
+  }
+
+  TISInputSourceRef name_source = TISCopyCurrentKeyboardInputSource();
+  CFStringRef localized_name = (CFStringRef) TISGetInputSourceProperty(name_source, kTISPropertyLocalizedName);
+  if(localized_name) {
+    NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "localizedName", std::string([(NSString *)localized_name UTF8String]).c_str()));
+  }
+
+  NSArray* languages = (NSArray *) TISGetInputSourceProperty(source, kTISPropertyInputSourceLanguages);
+  if (languages && [languages count] > 0) {
+    NSString* lang = [languages objectAtIndex:0];
+    if (lang) {
+      NAPI_CALL(env, napi_set_named_property_string_utf8(env, result, "lang", std::string([lang UTF8String]).c_str()));
+    }
+  }
+
+  return result;
+}
+
+void NotificationCallback(CFNotificationCenterRef center, void *observer, CFStringRef name, const void *object, CFDictionaryRef userInfo) {
+  NotificationCallbackData *data = (NotificationCallbackData *)observer;
+  InvokeNotificationCallback(data);
+}
+
+void RegisterKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data) {
+  CFNotificationCenterRef center = CFNotificationCenterGetDistributedCenter();
+
+  // add an observer
+  CFNotificationCenterAddObserver(center, data, NotificationCallback,
+    kTISNotifySelectedKeyboardInputSourceChanged, NULL,
+    CFNotificationSuspensionBehaviorDeliverImmediately
+  );
+}
+
+void DisposeKeyboardLayoutChangeListenerImpl(NotificationCallbackData *data) {
+  CFNotificationCenterRef center = CFNotificationCenterGetDistributedCenter();
+
+  // remove the observer
+  CFNotificationCenterRemoveObserver(center, data,
+    kTISNotifySelectedKeyboardInputSourceChanged, NULL
+  );
+}
+
+napi_value IsISOKeyboardImpl(napi_env env, napi_callback_info info) {
+  if (KBGetLayoutType(LMGetKbdType()) == kKeyboardISO) {
+    return napi_fetch_boolean(env, true);
+  } else {
+    return napi_fetch_boolean(env, false);
+  }
+}
+
+} // namespace vscode_keyboard