TeaSpeak/TeaSpeak-Client
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Made the client compatible with the newest webpack stuff

Browse Source
This commit is contained in:
WolverinDEV 2020-04-01 21:56:23 +02:00
parent c86b9510a5
commit 75b5192801
36 changed files with 2034 additions and 7414 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
github

@ -1 +1 @@
Subproject commit 171e88fa1f9e4ea67522c1f6bc07b5ca3c8f4b49
Subproject commit 6d45c4c883f9b2a53fe1bfeb23fe559b62a61cac

4
jenkins/create_build.sh
View File

@ -121,6 +121,6 @@ function deploy_client() {
#install_npm
#compile_scripts
#compile_native
#package_client
compile_native
package_client
deploy_client

2
modules/renderer/PersistentLocalStorage.ts
View File

@ -8,7 +8,7 @@ const SETTINGS_DIR = path.join(APP_DATA, "settings");
let _local_storage: {[key: string]: any} = {};
let _local_storage_save: {[key: string]: boolean} = {};
export async function initialize() {
await fs.mkdirs(SETTINGS_DIR);
await fs.mkdirp(SETTINGS_DIR);
const files = await fs.readdir(SETTINGS_DIR);
for(const file of files) {

5
modules/renderer/app_backend.ts
View File

@ -1,6 +1,9 @@
window["require_setup"](module);
import {createErrorModal} from "tc-shared/ui/elements/Modal";
import * as electron from "electron";
import {tr, tra} from "tc-shared/i18n/localize";
import {server_connections} from "tc-shared/ui/frames/connection_handlers";
import {handle_connect_request} from "tc-shared/main";
electron.ipcRenderer.on('connect', (event, url) => handle_native_connect_request(url));

119
modules/renderer/audio/AudioPlayer.ts
View File

@ -1,132 +1,73 @@
window["require_setup"](module);
import * as native from "tc-native/connection";
import {audio as naudio} from "teaclient_connection";
namespace audio.player {
//FIXME: Native audio initialize handle!
export interface Device {
//FIXME: Native audio initialize handle!
export interface Device {
device_id: string;
name: string;
}
}
interface Navigator {
mozGetUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
webkitGetUserMedia(constraints: MediaStreamConstraints, successCallback: NavigatorUserMediaSuccessCallback, errorCallback: NavigatorUserMediaErrorCallback): void;
}
let _initialized_callbacks: (() => any)[] = [];
export let _initialized = false;
export let _initializing = false;
export let _current_device: native.audio.AudioDevice;
let _initialized_callbacks: (() => any)[] = [];
export let _initialized = false;
export let _initializing = false;
export let _audioContext: AudioContext;
export let _processor: ScriptProcessorNode;
export let _output_stream: naudio.playback.OwnedAudioOutputStream;
export let _current_device: naudio.AudioDevice;
export function initialized() : boolean {
export function initialized() : boolean {
return _initialized;
}
export function context() : AudioContext {
if(!_audioContext) throw "Initialize first!";
return _audioContext;
}
export function destination() : AudioNode {
if(!_initialized)
throw "Audio player hasn't yet be initialized";
return _processor || _audioContext.destination;
}
export function on_ready(cb: () => any) {
}
export function on_ready(cb: () => any) {
if(_initialized)
cb();
else
_initialized_callbacks.push(cb);
}
}
export function initialize() {
export function initialize() {
if(_initializing) return;
_initializing = true;
naudio.initialize(() => {
_output_stream = naudio.playback.create_stream();
_output_stream.set_buffer_max_latency(0.4);
_output_stream.set_buffer_latency(0.02);
_output_stream.callback_overflow = () => {
console.warn("Main audio overflow");
_output_stream.clear();
};
_output_stream.callback_underflow = () => {
console.warn("Main audio underflow");
};
_audioContext = new AudioContext({
sampleRate: _output_stream.sample_rate
});
_processor = _audioContext.createScriptProcessor(1024 * 8, _output_stream.channels, _output_stream.channels);
_processor.onaudioprocess = function(event) {
const buffer = event.inputBuffer;
//console.log("Received %d channels of %d with a rate of %d", buffer.numberOfChannels, buffer.length, buffer.sampleRate);
const target_buffer = new Float32Array(buffer.numberOfChannels * buffer.length);
for(let channel = 0; channel < buffer.numberOfChannels; channel++) {
const channel_data = buffer.getChannelData(channel);
target_buffer.set(channel_data, channel * buffer.length);
}
_output_stream.write_data_rated(target_buffer.buffer, false, buffer.sampleRate);
};
_processor.connect(_audioContext.destination);
native.audio.initialize(() => {
_initialized = true;
for(const callback of _initialized_callbacks)
callback();
_initialized_callbacks = [];
});
return true;
}
}
export async function available_devices() : Promise<Device[]> {
return naudio.available_devices().filter(e => e.output_supported || e.output_default);
}
export async function available_devices() : Promise<Device[]> {
return native.audio.available_devices().filter(e => e.output_supported || e.output_default);
}
export async function set_device(device_id?: string) : Promise<void> {
const dev = naudio.available_devices().filter(e => e.device_id == device_id);
export async function set_device(device_id?: string) : Promise<void> {
const dev = native.audio.available_devices().filter(e => e.device_id == device_id);
if(dev.length == 0) {
console.warn("Missing audio device with is %s", device_id);
throw "invalid device id";
}
try {
naudio.playback.set_device(dev[0].device_id);
native.audio.playback.set_device(dev[0].device_id);
} catch(error) {
if(error instanceof Error)
throw error.message;
throw error;
}
_current_device = dev[0];
}
}
export function current_device() : Device {
export function current_device() : Device {
if(_current_device)
return _current_device;
const dev = naudio.available_devices().filter(e => e.output_default);
const dev = native.audio.available_devices().filter(e => e.output_default);
if(dev.length > 0)
return dev[0];
return {device_id: "default", name: "default"} as Device;
}
export function get_master_volume() : number {
return naudio.playback.get_master_volume();
}
export function set_master_volume(volume: number) {
naudio.playback.set_master_volume(volume);
}
}
Object.assign(window["audio"] || (window["audio"] = {} as any), audio);
export function get_master_volume() : number {
return native.audio.playback.get_master_volume();
}
export function set_master_volume(volume: number) {
native.audio.playback.set_master_volume(volume);
}

184
modules/renderer/audio/AudioRecorder.ts
View File

@ -1,24 +1,25 @@
window["require_setup"](module);
import {
filter,
AbstractInput,
InputDevice,
InputState,
InputConsumer,
InputConsumerType, InputStartResult, LevelMeter
} from "tc-shared/voice/RecorderBase";
import {audio} from "tc-native/connection";
import {tr} from "tc-shared/i18n/localize";
import {audio as naudio} from "teaclient_connection";
// <reference types="../imports/import_shared.d.ts" />
/// <reference types="../../modules/renderer/imports/imports_shared.d.ts" />
export namespace _audio.recorder {
import InputDevice = audio.recorder.InputDevice;
import AbstractInput = audio.recorder.AbstractInput;
interface NativeDevice extends InputDevice {
interface NativeDevice extends InputDevice {
device_index: number;
native: any;
}
}
let _device_cache: NativeDevice[] = undefined;
export function devices() : InputDevice[] {
let _device_cache: NativeDevice[] = undefined;
export function devices() : InputDevice[] {
//TODO: Handle device updates!
if(!naudio.initialized()) return [];
if(!audio.initialized()) return [];
return _device_cache || (_device_cache = naudio.available_devices().filter(e => e.input_supported || e.input_default).map(e => {
return _device_cache || (_device_cache = audio.available_devices().filter(e => e.input_supported || e.input_default).map(e => {
return {
unique_id: e.device_id,
channels: 2, /* TODO */
@ -30,18 +31,18 @@ export namespace _audio.recorder {
native: e
} as NativeDevice
}));
}
}
export function device_refresh_available() : boolean { return false; }
export function refresh_devices() : Promise<void> { throw "not supported yet!"; }
export function device_refresh_available() : boolean { return false; }
export function refresh_devices() : Promise<void> { throw "not supported yet!"; }
export function create_input() : AbstractInput {
export function create_input() : AbstractInput {
return new NativeInput();
}
}
namespace filter {
export abstract class NativeFilter implements audio.recorder.filter.Filter {
type: audio.recorder.filter.Type;
namespace filters {
export abstract class NativeFilter implements filter.Filter {
type: filter.Type;
handle: NativeInput;
enabled: boolean = false;
@ -54,8 +55,8 @@ export namespace _audio.recorder {
is_enabled(): boolean { return this.enabled; }
}
export class NThresholdFilter extends NativeFilter implements audio.recorder.filter.ThresholdFilter {
private filter: naudio.record.ThresholdConsumeFilter;
export class NThresholdFilter extends NativeFilter implements filter.ThresholdFilter {
private filter: audio.record.ThresholdConsumeFilter;
private _margin_frames: number = 6; /* 120ms */
private _threshold: number = 50;
@ -67,7 +68,7 @@ export namespace _audio.recorder {
callback_level: (level: number) => any;
constructor(handle) {
super(handle, audio.recorder.filter.Type.THRESHOLD);
super(handle, filter.Type.THRESHOLD);
Object.defineProperty(this, 'callback_level', {
get(): any {
@ -150,12 +151,12 @@ export namespace _audio.recorder {
}
}
export class NStateFilter extends NativeFilter implements audio.recorder.filter.StateFilter {
private filter: naudio.record.StateConsumeFilter;
export class NStateFilter extends NativeFilter implements filter.StateFilter {
private filter: audio.record.StateConsumeFilter;
private active = false;
constructor(handle) {
super(handle, audio.recorder.filter.Type.STATE);
super(handle, filter.Type.STATE);
}
finalize() {
@ -188,13 +189,13 @@ export namespace _audio.recorder {
}
}
export class NVoiceLevelFilter extends NativeFilter implements audio.recorder.filter.VoiceLevelFilter {
private filter: naudio.record.VADConsumeFilter;
export class NVoiceLevelFilter extends NativeFilter implements filter.VoiceLevelFilter {
private filter: audio.record.VADConsumeFilter;
private level = 3;
private _margin_frames = 5;
constructor(handle) {
super(handle, audio.recorder.filter.Type.VOICE_LEVEL);
super(handle, filter.Type.VOICE_LEVEL);
}
finalize() {
@ -239,65 +240,65 @@ export namespace _audio.recorder {
return this.filter ? this.filter.get_margin_frames() : this._margin_frames;
}
}
}
}
export class NativeInput implements AbstractInput {
private handle: naudio.record.AudioRecorder;
consumer: naudio.record.AudioConsumer;
export class NativeInput implements AbstractInput {
private handle: audio.record.AudioRecorder;
consumer: audio.record.AudioConsumer;
private _current_device: audio.recorder.InputDevice;
private _current_state: audio.recorder.InputState = audio.recorder.InputState.PAUSED;
private _current_device: InputDevice;
private _current_state: InputState = InputState.PAUSED;
callback_begin: () => any;
callback_end: () => any;
private filters: filter.NativeFilter[] = [];
private filters: filters.NativeFilter[] = [];
constructor() {
this.handle = naudio.record.create_recorder();
this.handle = audio.record.create_recorder();
this.consumer = this.handle.create_consumer();
this.consumer.callback_ended = () => {
if(this._current_state !== audio.recorder.InputState.RECORDING)
if(this._current_state !== InputState.RECORDING)
return;
this._current_state = audio.recorder.InputState.DRY;
this._current_state = InputState.DRY;
if(this.callback_end)
this.callback_end();
};
this.consumer.callback_started = () => {
if(this._current_state !== audio.recorder.InputState.DRY)
if(this._current_state !== InputState.DRY)
return;
this._current_state = audio.recorder.InputState.RECORDING;
this._current_state = InputState.RECORDING;
if(this.callback_begin)
this.callback_begin();
};
this._current_state = audio.recorder.InputState.PAUSED;
this._current_state = InputState.PAUSED;
}
/* TODO: some kind of finalize? */
current_consumer(): audio.recorder.InputConsumer | undefined {
current_consumer(): InputConsumer | undefined {
return {
type: audio.recorder.InputConsumerType.NATIVE
type: InputConsumerType.NATIVE
};
}
async set_consumer(consumer: audio.recorder.InputConsumer): Promise<void> {
async set_consumer(consumer: InputConsumer): Promise<void> {
if(typeof(consumer) !== "undefined")
throw "we only support native consumers!"; /* TODO: May create a general wrapper? */
return;
}
async set_device(_device: audio.recorder.InputDevice | undefined): Promise<void> {
async set_device(_device: InputDevice | undefined): Promise<void> {
if(_device === this._current_device)
return;
this._current_device = _device;
try {
await new Promise(resolve => this.handle.set_device(this._current_device ? this._current_device.unique_id : undefined, resolve));
if(this._current_state !== audio.recorder.InputState.PAUSED && this._current_device)
if(this._current_state !== InputState.PAUSED && this._current_device)
await new Promise((resolve, reject) => {
this.handle.start(flag => {
if(typeof flag === "boolean" && flag)
@ -312,23 +313,23 @@ export namespace _audio.recorder {
}
}
current_device(): audio.recorder.InputDevice | undefined {
current_device(): InputDevice | undefined {
return this._current_device;
}
current_state(): audio.recorder.InputState {
current_state(): InputState {
return this._current_state;
}
disable_filter(type: audio.recorder.filter.Type) {
const filter = this.get_filter(type) as filter.NativeFilter;
disable_filter(type: filter.Type) {
const filter = this.get_filter(type) as filters.NativeFilter;
if(filter.is_enabled())
filter.enabled = false;
filter.finalize();
}
enable_filter(type: audio.recorder.filter.Type) {
const filter = this.get_filter(type) as filter.NativeFilter;
enable_filter(type: filter.Type) {
const filter = this.get_filter(type) as filters.NativeFilter;
if(!filter.is_enabled()) {
filter.enabled = true;
filter.initialize();
@ -342,21 +343,21 @@ export namespace _audio.recorder {
}
}
get_filter(type: audio.recorder.filter.Type): audio.recorder.filter.Filter | undefined {
get_filter(type: filter.Type): filter.Filter | undefined {
for(const filter of this.filters)
if(filter.type === type)
return filter;
let _filter: filter.NativeFilter;
let _filter: filters.NativeFilter;
switch (type) {
case audio.recorder.filter.Type.THRESHOLD:
_filter = new filter.NThresholdFilter(this);
case filter.Type.THRESHOLD:
_filter = new filters.NThresholdFilter(this);
break;
case audio.recorder.filter.Type.STATE:
_filter = new filter.NStateFilter(this);
case filter.Type.STATE:
_filter = new filters.NStateFilter(this);
break;
case audio.recorder.filter.Type.VOICE_LEVEL:
_filter = new filter.NVoiceLevelFilter(this);
case filter.Type.VOICE_LEVEL:
_filter = new filters.NVoiceLevelFilter(this);
break;
default:
throw "this filter isn't supported!";
@ -365,25 +366,25 @@ export namespace _audio.recorder {
return _filter;
}
supports_filter(type: audio.recorder.filter.Type) : boolean {
supports_filter(type: filter.Type) : boolean {
switch (type) {
case audio.recorder.filter.Type.THRESHOLD:
case audio.recorder.filter.Type.STATE:
case audio.recorder.filter.Type.VOICE_LEVEL:
case filter.Type.THRESHOLD:
case filter.Type.STATE:
case filter.Type.VOICE_LEVEL:
return true;
default:
return false;
}
}
async start(): Promise<audio.recorder.InputStartResult> {
async start(): Promise<InputStartResult> {
try {
await this.stop();
} catch(error) {
console.warn(tr("Failed to stop old record session before start (%o)"), error);
}
this._current_state = audio.recorder.InputState.DRY;
this._current_state = InputState.DRY;
try {
if(this._current_device)
await new Promise((resolve, reject) => {
@ -397,9 +398,9 @@ export namespace _audio.recorder {
for(const filter of this.filters)
if(filter.is_enabled())
filter.initialize();
return audio.recorder.InputStartResult.EOK;
return InputStartResult.EOK;
} catch(error) {
this._current_state = audio.recorder.InputState.PAUSED;
this._current_state = InputState.PAUSED;
throw error;
}
}
@ -410,7 +411,7 @@ export namespace _audio.recorder {
filter.finalize();
if(this.callback_end)
this.callback_end();
this._current_state = audio.recorder.InputState.PAUSED;
this._current_state = InputState.PAUSED;
}
get_volume(): number {
@ -420,21 +421,21 @@ export namespace _audio.recorder {
set_volume(volume: number) {
this.handle.set_volume(volume);
}
}
}
export async function create_levelmeter(device: InputDevice) : Promise<audio.recorder.LevelMeter> {
export async function create_levelmeter(device: InputDevice) : Promise<LevelMeter> {
const meter = new NativeLevelmenter(device as any);
await meter.initialize();
return meter;
}
}
class NativeLevelmenter implements audio.recorder.LevelMeter {
class NativeLevelmenter implements LevelMeter {
readonly _device: NativeDevice;
private _callback: (num: number) => any;
private _recorder: naudio.record.AudioRecorder;
private _consumer: naudio.record.AudioConsumer;
private _filter: naudio.record.ThresholdConsumeFilter;
private _recorder: audio.record.AudioRecorder;
private _consumer: audio.record.AudioConsumer;
private _filter: audio.record.ThresholdConsumeFilter;
constructor(device: NativeDevice) {
this._device = device;
@ -442,7 +443,7 @@ export namespace _audio.recorder {
async initialize() {
try {
this._recorder = naudio.record.create_recorder();
this._recorder = audio.record.create_recorder();
this._consumer = this._recorder.create_consumer();
this._filter = this._consumer.create_filter_threshold(.5);
@ -452,14 +453,14 @@ export namespace _audio.recorder {
await new Promise(resolve => this._recorder.set_device(this._device ? this._device.unique_id : undefined, resolve));
await new Promise((resolve, reject) => {
this._recorder.start(flag => {
if(typeof flag === "boolean" && flag)
if (typeof flag === "boolean" && flag)
resolve();
else
reject(typeof flag === "string" ? flag : "failed to start");
});
});
} catch(error) {
if(typeof(error) === "string")
} catch (error) {
if (typeof (error) === "string")
throw error;
console.warn(tr("Failed to initialize levelmeter for device %o: %o"), this._device, error);
throw "initialize failed (lookup console)";
@ -467,32 +468,31 @@ export namespace _audio.recorder {
/* references this variable, needs a destory() call, else memory leak */
this._filter.set_analyze_filter(value => {
(this._callback || (() => {}))(value);
(this._callback || (() => {
}))(value);
});
}
destory() {
if(this._filter) {
if (this._filter) {
this._filter.set_analyze_filter(undefined);
this._consumer.unregister_filter(this._filter);
}
if(this._consumer)
if (this._consumer)
this._recorder.delete_consumer(this._consumer);
this._recorder.stop();
this._recorder.set_device(undefined, () => {}); /* -1 := No device */
this._recorder.set_device(undefined, () => {
}); /* -1 := No device */
this._recorder = undefined;
this._consumer = undefined;
this._filter = undefined;
}
device(): audio.recorder.InputDevice {
device(): InputDevice {
return this._device;
}
set_observer(callback: (value: number) => any) {
this._callback = callback;
}
}
}
Object.assign(window["audio"] || (window["audio"] = {} as any), _audio);

13
modules/renderer/audio/sounds.ts
View File

@ -1,12 +1,8 @@
window["require_setup"](module);
// <reference types="../imports/import_shared.d.ts" />
/// <reference types="../../modules/renderer/imports/imports_shared.d.ts" />
import {audio as naudio} from "teaclient_connection";
import {audio as naudio} from "tc-native/connection";
import * as paths from "path";
import {SoundFile} from "tc-shared/sound/Sounds";
namespace audio.sounds {
export async function play_sound(file: sound.SoundFile) : Promise<void> {
export async function play_sound(file: SoundFile) : Promise<void> {
await new Promise((resolve, reject) => {
let pathname = paths.dirname(decodeURIComponent(location.pathname));
if(pathname[0] === '/' && pathname[2] === ':') //e.g.: /C:/test...
@ -25,7 +21,4 @@ namespace audio.sounds {
volume: file.volume
});
});
}
}
Object.assign(window["audio"] || (window["audio"] = {} as any), audio);

16
modules/renderer/backend-impl/audio/player.ts Normal file
View File

@ -0,0 +1,16 @@
import * as handler from "../../audio/AudioPlayer";
export const initialize = handler.initialize;
export const initialized = handler.initialized;
export const context = handler.context;
export const get_master_volume = handler.get_master_volume;
export const set_master_volume = handler.set_master_volume;
export const on_ready = handler.on_ready;
export const available_devices = handler.available_devices;
export const set_device = handler.set_device;
export const current_device = handler.current_device;
export const initializeFromGesture = () => {};

8
modules/renderer/backend-impl/audio/recorder.ts Normal file
View File

@ -0,0 +1,8 @@
import * as handler from "../../audio/AudioRecorder";
export const devices = handler.devices;
export const device_refresh_available = handler.device_refresh_available;
export const refresh_devices = handler.refresh_devices;
export const create_input = handler.create_input;
export const create_levelmeter = handler.create_levelmeter;

3
modules/renderer/backend-impl/audio/sounds.ts Normal file
View File

@ -0,0 +1,3 @@
import * as handler from "../../audio/sounds";
export const play_sound = handler.play_sound;

4
modules/renderer/backend-impl/connection.ts Normal file
View File

@ -0,0 +1,4 @@
import * as handler from "../connection/ServerConnection";
export const spawn_server_connection = handler.spawn_server_connection;
export const destroy_server_connection = handler.destroy_server_connection;

4
modules/renderer/backend-impl/dns.ts Normal file
View File

@ -0,0 +1,4 @@
import * as handler from "../dns/dns_resolver";
export const supported = handler.supported;
export const resolve_address = handler.resolve_address;

12
modules/renderer/backend-impl/ppt.ts Normal file
View File

@ -0,0 +1,12 @@
import * as handler from "../ppt";
export const initialize = handler.initialize;
export const finalize = handler.finalize;
export const register_key_listener = handler.register_key_listener;
export const unregister_key_listener = handler.unregister_key_listener;
export const register_key_hook = handler.register_key_hook;
export const unregister_key_hook = handler.unregister_key_hook;
export const key_pressed = handler.key_pressed;

48
modules/renderer/connection/FileTransfer.ts
View File

@ -1,13 +1,10 @@
/// <reference path="../imports/imports_shared.d.ts" />
window["require_setup"](module);
import * as native from "teaclient_connection";
import * as native from "tc-native/connection";
import * as path from "path";
import {DownloadKey, DownloadTransfer, UploadKey, UploadTransfer} from "tc-shared/FileManager";
import {base64_encode_ab, str2ab8} from "tc-shared/utils/buffers";
namespace _transfer {
class NativeFileDownload implements transfer.DownloadTransfer {
readonly key: transfer.DownloadKey;
class NativeFileDownload implements DownloadTransfer {
readonly key: DownloadKey;
private _handle: native.ft.NativeFileTransfer;
private _buffer: Uint8Array;
@ -17,7 +14,7 @@ namespace _transfer {
private _result_success: () => any;
private _result_error: (error: any) => any;
constructor(key: transfer.DownloadKey) {
constructor(key: DownloadKey) {
this.key = key;
this._buffer = new Uint8Array(key.total_size);
this._handle = native.ft.spawn_connection({
@ -33,7 +30,7 @@ namespace _transfer {
});
}
get_key(): transfer.DownloadKey {
get_key(): DownloadKey {
return this.key;
}
@ -87,10 +84,10 @@ namespace _transfer {
this._handle.start();
});
}
}
}
class NativeFileUpload implements transfer.UploadTransfer {
readonly transfer_key: transfer.UploadKey;
class NativeFileUpload implements UploadTransfer {
readonly transfer_key: UploadKey;
private _handle: native.ft.NativeFileTransfer;
private _result: Promise<void>;
@ -98,7 +95,7 @@ namespace _transfer {
private _result_success: () => any;
private _result_error: (error: any) => any;
constructor(key: transfer.UploadKey) {
constructor(key: UploadKey) {
this.transfer_key = key;
}
@ -167,20 +164,17 @@ namespace _transfer {
}));
}
get_key(): transfer.UploadKey {
get_key(): UploadKey {
return this.transfer_key;
}
}
export function spawn_download_transfer(key: transfer.DownloadKey) : transfer.DownloadTransfer {
return new NativeFileDownload(key);
}
export function spawn_upload_transfer(key: transfer.UploadKey) : transfer.UploadTransfer {
return new NativeFileUpload(key);
}
}
Object.assign(window["transfer"] || (window["transfer"] = {} as any), _transfer);
export function spawn_download_transfer(key: DownloadKey) : DownloadTransfer {
return new NativeFileDownload(key);
}
export function spawn_upload_transfer(key: UploadKey) : UploadTransfer {
return new NativeFileUpload(key);
}

88
modules/renderer/connection/ServerConnection.ts
View File

@ -1,19 +1,22 @@
/// <reference path="../imports/imports_shared.d.ts" />
window["require_setup"](module);
import {AbstractCommandHandler, AbstractCommandHandlerBoss} from "tc-shared/connection/AbstractCommandHandler";
import {
destroy_server_connection as _destroy_server_connection,
NativeServerConnection,
ServerType,
spawn_server_connection as _spawn_server_connection
} from "teaclient_connection";
import {_audio} from "./VoiceConnection";
AbstractServerConnection, CommandOptionDefaults, CommandOptions,
ConnectionStateListener,
ServerCommand,
voice
} from "tc-shared/connection/ConnectionBase";
import {CommandResult} from "tc-shared/connection/ServerConnectionDeclaration";
import {tr} from "tc-shared/i18n/localize";
import {ConnectionHandler, ConnectionState, DisconnectReason} from "tc-shared/ConnectionHandler";
import {NativeServerConnection, ServerType, spawn_server_connection as spawn_native_server_connection, destroy_server_connection as destroy_native_server_connection} from "tc-native/connection";
import {ConnectionCommandHandler} from "tc-shared/connection/CommandHandler";
import {HandshakeHandler} from "tc-shared/connection/HandshakeHandler";
import {ServerAddress} from "tc-shared/ui/server";
import {TeaSpeakHandshakeHandler} from "tc-shared/profiles/identities/TeamSpeakIdentity";
import AbstractVoiceConnection = voice.AbstractVoiceConnection;
import {VoiceConnection} from "./VoiceConnection";
export namespace _connection {
export namespace native {
import VoiceConnection = _audio.native.VoiceConnection;
class ErrorCommandHandler extends connection.AbstractCommandHandler {
class ErrorCommandHandler extends AbstractCommandHandler {
private _handle: ServerConnection;
constructor(handle: ServerConnection) {
@ -21,7 +24,7 @@ export namespace _connection {
this._handle = handle;
}
handle_command(command: connection.ServerCommand): boolean {
handle_command(command: ServerCommand): boolean {
if(command.command === "error") {
const return_listener: {[key: string]: (result: CommandResult) => any} = this._handle["_return_listener"];
const data = command.arguments[0];
@ -105,9 +108,9 @@ export namespace _connection {
}
return false;
}
}
}
export class ServerConnection extends connection.AbstractServerConnection {
export class ServerConnection extends AbstractServerConnection {
private _native_handle: NativeServerConnection;
private _voice_connection: VoiceConnection;
@ -116,26 +119,26 @@ export namespace _connection {
private _command_handler: NativeConnectionCommandBoss;
private _command_error_handler: ErrorCommandHandler;
private _command_handler_default: connection.ConnectionCommandHandler;
private _command_handler_default: ConnectionCommandHandler;
private _remote_address: ServerAddress;
private _handshake_handler: connection.HandshakeHandler;
private _handshake_handler: HandshakeHandler;
private _return_code_index: number = 0;
onconnectionstatechanged: connection.ConnectionStateListener;
onconnectionstatechanged: ConnectionStateListener;
constructor(props: ConnectionHandler) {
super(props);
this._command_handler = new NativeConnectionCommandBoss(this);
this._command_error_handler = new ErrorCommandHandler(this);
this._command_handler_default = new connection.ConnectionCommandHandler(this);
this._command_handler_default = new ConnectionCommandHandler(this);
this._command_handler.register_handler(this._command_error_handler);
this._command_handler.register_handler(this._command_handler_default);
this._native_handle = _spawn_server_connection();
this._native_handle = spawn_native_server_connection();
this._native_handle.callback_disconnect = reason => {
this.client.handleDisconnect(DisconnectReason.CONNECTION_CLOSED, {
reason: reason,
@ -163,11 +166,11 @@ export namespace _connection {
finalize() {
if(this._native_handle)
_destroy_server_connection(this._native_handle);
destroy_native_server_connection(this._native_handle);
this._native_handle = undefined;
}
connect(address: ServerAddress, handshake: connection.HandshakeHandler, timeout?: number): Promise<void> {
connect(address: ServerAddress, handshake: HandshakeHandler, timeout?: number): Promise<void> {
this._remote_address = address;
this._handshake_handler = handshake;
this._do_teamspeak = false;
@ -199,7 +202,7 @@ export namespace _connection {
}
},
identity_key: (handshake.get_identity_handler() as profiles.identities.TeaSpeakHandshakeHandler).identity.private_key,
identity_key: (handshake.get_identity_handler() as TeaSpeakHandshakeHandler).identity.private_key,
teamspeak: false
})
});
@ -210,7 +213,7 @@ export namespace _connection {
return this._remote_address;
}
handshake_handler(): connection.HandshakeHandler {
handshake_handler(): HandshakeHandler {
return this._handshake_handler;
}
@ -232,11 +235,11 @@ export namespace _connection {
return true;
}
voice_connection(): connection.voice.AbstractVoiceConnection {
voice_connection(): AbstractVoiceConnection {
return this._voice_connection;
}
command_handler_boss(): connection.AbstractCommandHandlerBoss {
command_handler_boss(): AbstractCommandHandlerBoss {
return this._command_handler;
}
@ -244,14 +247,14 @@ export namespace _connection {
return (this._return_code_index++).toString();
}
send_command(command: string, data?: any, _options?: connection.CommandOptions): Promise<CommandResult> {
send_command(command: string, data?: any, _options?: CommandOptions): Promise<CommandResult> {
if(!this.connected()) {
console.warn(tr("Tried to send a command without a valid connection."));
return Promise.reject(tr("not connected"));
}
const options: connection.CommandOptions = {};
Object.assign(options, connection.CommandOptionDefaults);
const options: CommandOptions = {};
Object.assign(options, CommandOptionDefaults);
Object.assign(options, _options);
data = $.isArray(data) ? data : [data || {}];
@ -292,27 +295,24 @@ export namespace _connection {
native: this._native_handle ? (this._native_handle.current_ping() / 1000) : -2
};
}
}
}
}
export class NativeConnectionCommandBoss extends connection.AbstractCommandHandlerBoss {
constructor(connection: connection.AbstractServerConnection) {
export class NativeConnectionCommandBoss extends AbstractCommandHandlerBoss {
constructor(connection: AbstractServerConnection) {
super(connection);
}
}
}
/* override the "normal" connection */
export function spawn_server_connection(handle: ConnectionHandler) : connection.AbstractServerConnection {
/* override the "normal" connection */
export function spawn_server_connection(handle: ConnectionHandler) : AbstractServerConnection {
console.log("Spawning native connection");
return new native.ServerConnection(handle); /* will be overridden by the client */
}
return new ServerConnection(handle); /* will be overridden by the client */
}
export function destroy_server_connection(handle: connection.AbstractServerConnection) {
if(!(handle instanceof native.ServerConnection))
export function destroy_server_connection(handle: AbstractServerConnection) {
if(!(handle instanceof ServerConnection))
throw "invalid handle";
//TODO: Here!
console.log("Call to destroy a server connection");
}
}
Object.assign(window["connection"] || (window["connection"] = {} as any), _connection);

40
modules/renderer/connection/VoiceConnection.ts
View File

@ -1,16 +1,16 @@
import {_connection} from "./ServerConnection";
import {_audio as _recorder} from "../audio/AudioRecorder";
import {voice} from "tc-shared/connection/ConnectionBase";
import AbstractVoiceConnection = voice.AbstractVoiceConnection;
import {ServerConnection} from "./ServerConnection";
import {NativeVoiceConnection} from "tc-native/connection";
import {RecorderProfile} from "tc-shared/voice/RecorderProfile";
import {tr} from "tc-shared/i18n/localize";
import {LogCategory} from "tc-shared/log";
import * as log from "tc-shared/log";
import VoiceClient = voice.VoiceClient;
import LatencySettings = voice.LatencySettings;
import {NativeInput} from "../audio/AudioRecorder";
import {
NativeVoiceConnection,
NativeVoiceClient
} from "teaclient_connection";
export namespace _audio {
export namespace native {
import ServerConnection = _connection.native.ServerConnection;
export class VoiceConnection extends connection.voice.AbstractVoiceConnection {
export class VoiceConnection extends AbstractVoiceConnection {
readonly connection: ServerConnection;
readonly handle: NativeVoiceConnection;
@ -32,7 +32,7 @@ export namespace _audio {
await this._audio_source.unmount();
if(recorder) {
if(!(recorder.input instanceof _recorder.recorder.NativeInput))
if(!(recorder.input instanceof NativeInput))
throw "Recorder input must be an instance of NativeInput!";
await recorder.unmount();
}
@ -56,7 +56,7 @@ export namespace _audio {
this.connection.client.update_voice_status(undefined);
};
this.handle.set_audio_source((recorder.input as _recorder.recorder.NativeInput).consumer);
this.handle.set_audio_source((recorder.input as NativeInput).consumer);
}
this.connection.client.update_voice_status(undefined);
}
@ -114,7 +114,7 @@ export namespace _audio {
return this._audio_source;
}
available_clients(): connection.voice.VoiceClient[] {
available_clients(): VoiceClient[] {
return this.handle.available_clients().map(e => Object.assign(e, {
support_latency_settings() { return true; },
reset_latency_settings: function() {
@ -123,7 +123,7 @@ export namespace _audio {
stream.set_buffer_max_latency(0.2);
return this.latency_settings();
},
latency_settings: function (settings?: connection.voice.LatencySettings) : connection.voice.LatencySettings {
latency_settings: function (settings?: LatencySettings) : LatencySettings {
const stream = this.get_stream();
if(typeof settings !== "undefined") {
stream.set_buffer_latency(settings.min_buffer / 1000);
@ -143,19 +143,19 @@ export namespace _audio {
}));
}
find_client(client_id: number) : connection.voice.VoiceClient | undefined {
find_client(client_id: number) : VoiceClient | undefined {
for(const client of this.available_clients())
if(client.client_id === client_id)
return client;
return undefined;
}
unregister_client(client: connection.voice.VoiceClient): Promise<void> {
unregister_client(client: VoiceClient): Promise<void> {
this.handle.unregister_client(client.client_id);
return Promise.resolve();
}
register_client(client_id: number): connection.voice.VoiceClient {
register_client(client_id: number): VoiceClient {
const client = this.handle.register_client(client_id);
const c = this.find_client(client_id);
c.reset_latency_settings();
@ -177,6 +177,4 @@ export namespace _audio {
set_encoder_codec(codec: number) {
return this.handle.set_encoder_codec(codec);
}
}
}
}

6
modules/renderer/context-menu.ts
View File

@ -1,7 +1,5 @@
import {class_to_image} from "./icon-helper";
window["require_setup"](module);
import * as contextmenu from "tc-shared/ui/elements/ContextMenu";
import * as electron from "electron";
const remote = electron.remote;
const {Menu, MenuItem} = remote;
@ -124,5 +122,3 @@ class ElectronContextMenu implements contextmenu.ContextMenuProvider {
}
contextmenu.set_provider(new ElectronContextMenu());
export {};

16
modules/renderer/dns/dns_resolver.ts
View File

@ -1,11 +1,11 @@
/// <reference path="../imports/imports_shared.d.ts" />
import {ServerAddress} from "tc-shared/ui/server";
import * as loader from "tc-loader";
window["require_setup"](module);
import * as dns_handler from "teaclient_dns";
import {AddressTarget, ResolveOptions} from "tc-shared/dns";
import * as dns_handler from "tc-native/dns";
namespace _dns {
export function supported() { return true; }
export async function resolve_address(address: ServerAddress, _options?: dns.ResolveOptions) : Promise<dns.AddressTarget> {
export function supported() { return true; }
export async function resolve_address(address: ServerAddress, _options?: ResolveOptions) : Promise<AddressTarget> {
/* backwards compatibility */
if(typeof(address) === "string") {
address = {
@ -14,7 +14,7 @@ namespace _dns {
}
}
return new Promise<dns.AddressTarget>((resolve, reject) => {
return new Promise<AddressTarget>((resolve, reject) => {
dns_handler.resolve_cr(address.host, address.port, result => {
if(typeof(result) === "string")
reject(result);
@ -25,10 +25,8 @@ namespace _dns {
});
});
})
}
}
Object.assign(window["dns"] || (window["dns"] = {} as any), _dns);
loader.register_task(loader.Stage.JAVASCRIPT_INITIALIZING, {
name: "Native DNS initialized",
function: async () => {

2
modules/renderer/icon-helper.ts
View File

@ -33,7 +33,7 @@ export function class_to_image(klass: string) : NativeImage {
export async function initialize() {
if(!_div) {
_div = $.spawn("div");
_div = $(document.createElement("div"));
_div.css('display', 'none');
_div.appendTo(document.body);
}

5426
modules/renderer/imports/.copy_imports_shared.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

97
modules/renderer/imports/.copy_imports_shared_loader.d.ts vendored
View File

@ -1,97 +0,0 @@
/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/loader/loader.ts */
declare interface Window {
tr(message: string): string;
}
declare namespace loader {
export namespace config {
export const loader_groups;
export const verbose;
export const error;
}
export type Task = {
name: string;
priority: number; /* tasks with the same priority will be executed in sync */
function: () => Promise<void>;
};
export enum Stage {
/*
loading loader required files (incl this)
*/
INITIALIZING,
/*
setting up the loading process
*/
SETUP,
/*
loading all style sheet files
*/
STYLE,
/*
loading all javascript files
*/
JAVASCRIPT,
/*
loading all template files
*/
TEMPLATES,
/*
initializing static/global stuff
*/
JAVASCRIPT_INITIALIZING,
/*
finalizing load process
*/
FINALIZING,
/*
invoking main task
*/
LOADED,
DONE
}
export function get_cache_version();
export function finished();
export function running();
export function register_task(stage: Stage, task: Task);
export function execute(): Promise<any>;
export function execute_managed();
export type DependSource = {
url: string;
depends: string[];
};
export type SourcePath = string | DependSource | string[];
export class SyntaxError {
source: any;
constructor(source: any);
}
export function load_script(path: SourcePath): Promise<void>;
export function load_scripts(paths: SourcePath[]): Promise<void>;
export function load_style(path: SourcePath): Promise<void>;
export function load_styles(paths: SourcePath[]): Promise<void>;
export type ErrorHandler = (message: string, detail: string) => void;
export function critical_error(message: string, detail?: string);
export function critical_error_handler(handler?: ErrorHandler, override?: boolean): ErrorHandler;
}
declare let _fadeout_warned;
declare function fadeoutLoader(duration?, minAge?, ignoreAge?);
/* File: /home/wolverindev/TeaSpeak/Web-Client/shared/loader/app.ts */
declare interface Window {
$: JQuery;
}
declare namespace app {
export enum Type {
UNKNOWN,
CLIENT_RELEASE,
CLIENT_DEBUG,
WEB_DEBUG,
WEB_RELEASE
}
export let type: Type;
export function is_web();
export function ui_version();
}
declare const loader_javascript;
declare const loader_webassembly;
declare const loader_style;
declare function load_templates(): Promise<any>;

2
modules/renderer/imports/.gitignore vendored
View File

@ -1,2 +0,0 @@
imports_shared.d.ts
imports_shared_loader.d.ts

290
modules/renderer/index.ts
View File

@ -1,12 +1,7 @@
/// <reference path="imports/imports_shared.d.ts" />
import {Arguments, parse_arguments, process_args} from "../shared/process-arguments";
import * as electron from "electron";
import {remote} from "electron";
/* --------------- bootstrap --------------- */
import * as rh from "./require-handler";
import * as crash_handler from "../crash_handler";
import * as path from "path";
import * as os from "os";
import ipcRenderer = electron.ipcRenderer;
/* first of all setup crash handler */
{
@ -14,7 +9,9 @@ import ipcRenderer = electron.ipcRenderer;
crash_handler.initialize_handler("renderer", is_electron_run);
}
interface Window {
/* some decls */
declare global {
interface Window {
$: any;
jQuery: any;
jsrender: any;
@ -24,117 +21,50 @@ interface Window {
teaclient_initialize: any;
open_connected_question: () => Promise<boolean>;
}
}
rh.initialize(path.join(__dirname, "backend-impl"));
/* --------------- main initialize --------------- */
import {Arguments, parse_arguments, process_args} from "../shared/process-arguments";
import * as electron from "electron";
import {remote} from "electron";
import * as os from "os";
import * as loader from "tc-loader";
import ipcRenderer = electron.ipcRenderer;
declare const window: Window;
export const require_native: NodeRequireFunction = id => require(id);
export const initialize = async () => {
/* we use out own jquery resource */
loader.register_task(loader.Stage.JAVASCRIPT, {
/* we use out own jquery resource */
loader.register_task(loader.Stage.JAVASCRIPT, {
name: "teaclient jquery",
function: jquery_initialize,
function: async () => {
window.$ = require("jquery");
window.jQuery = window.$;
Object.assign(window.$, window.jsrender = require('jsrender'));
},
priority: 80
});
});
loader.register_task(loader.Stage.JAVASCRIPT, {
name: "teaclient general",
function: load_basic_modules,
priority: 10
});
loader.register_task(loader.Stage.JAVASCRIPT_INITIALIZING, {
name: "teaclient javascript init",
function: load_modules,
priority: 50
});
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize modules",
function: module_loader_setup,
priority: 60
});
loader.register_task(loader.Stage.INITIALIZING, {
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize persistent storage",
function: async () => {
const storage = require("./PersistentLocalStorage");
await storage.initialize();
},
priority: 90
});
});
loader.register_task(loader.Stage.INITIALIZING, {
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize logging",
function: initialize_logging,
priority: 80
});
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize error",
function: initialize_error_handler,
priority: 100
});
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize arguments",
function: async () => {
parse_arguments();
if(process_args.has_value(Arguments.DUMMY_CRASH_RENDERER))
crash_handler.handler.crash();
if(!process_args.has_flag(Arguments.DEBUG)) {
window.open_connected_question = () => remote.dialog.showMessageBox(remote.getCurrentWindow(), {
type: 'question',
buttons: ['Yes', 'No'],
title: 'Confirm',
message: 'Are you really sure?\nYou\'re still connected!'
}).then(result => result.response === 0);
}
},
priority: 110
});
loader.register_task(loader.Stage.INITIALIZING, {
name: 'gdb-waiter',
function: async () => {
if(process_args.has_flag(Arguments.DEV_TOOLS_GDB)) {
console.log("Process ID: %d", process.pid);
await new Promise(resolve => {
console.log("Waiting for continue!");
const listener = () => {
console.log("Continue");
document.removeEventListener('click', listener);
resolve();
};
document.addEventListener('click', listener);
});
}
},
priority: 100
});
loader.register_task(loader.Stage.LOADED, {
name: "argv connect",
function: async () => {
ipcRenderer.send('basic-action', "parse-connect-arguments");
},
priority: 0
})
};
const jquery_initialize = async () => {
window.$ = require("jquery");
window.jQuery = window.$;
Object.assign(window.$, window.jsrender = require('jsrender'));
};
const initialize_logging = async () => {
const logger = require("./logger");
logger.setup();
};
},
priority: 80
});
const initialize_error_handler = async () => {
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize error",
function: async () => {
const _impl = message => {
if(!process_args.has_flag(Arguments.DEBUG)) {
console.error("Displaying critical error: %o", message);
@ -159,121 +89,75 @@ const initialize_error_handler = async () => {
window.impl_display_critical_error = _impl;
else
window.displayCriticalError = _impl;
};
},
priority: 100
});
const module_loader_setup = async () => {
const native_paths = (() => {
const app_path = (remote || electron).app.getAppPath();
const result = [];
result.push(app_path + "/native/build/" + os.platform() + "_" + os.arch() + "/");
if(app_path.endsWith(".asar"))
result.push(path.join(path.dirname(app_path), "natives"));
return result;
})();
window["require_setup"] = _mod => {
if(!_mod || !_mod.paths) return;
_mod.paths.push(...native_paths);
const original_require = _mod.__proto__.require;
if(!_mod.proxied) {
_mod.require = (path: string) => {
if(path.endsWith("imports/imports_shared")) {
console.log("Proxy require for %s. Using 'window' as result.", path);
return window;
loader.register_task(loader.Stage.INITIALIZING, {
name: "teaclient initialize arguments",
function: async () => {
parse_arguments();
if(process_args.has_value(Arguments.DUMMY_CRASH_RENDERER))
crash_handler.handler.crash();
if(!process_args.has_flag(Arguments.DEBUG)) {
window.open_connected_question = () => remote.dialog.showMessageBox(remote.getCurrentWindow(), {
type: 'question',
buttons: ['Yes', 'No'],
title: 'Confirm',
message: 'Are you really sure?\nYou\'re still connected!'
}).then(result => result.response === 0);
}
return original_require.apply(_mod, [path]);
},
priority: 110
});
loader.register_task(loader.Stage.INITIALIZING, {
name: 'gdb-waiter',
function: async () => {
if(process_args.has_flag(Arguments.DEV_TOOLS_GDB)) {
console.log("Process ID: %d", process.pid);
await new Promise(resolve => {
console.log("Waiting for continue!");
const listener = () => {
console.log("Continue");
document.removeEventListener('click', listener);
resolve();
};
_mod.proxied = true;
document.addEventListener('click', listener);
});
}
};
};
},
priority: 100
});
const load_basic_modules = async () => {
require("./logger");
loader.register_task(loader.Stage.LOADED, {
name: "argv connect",
function: async () => {
ipcRenderer.send('basic-action', "parse-connect-arguments");
},
priority: 0
});
require("./audio/AudioPlayer"); /* setup audio */
require("./audio/AudioRecorder"); /* setup audio */
require("./audio/sounds"); /* setup audio */
};
const load_modules = async () => {
window["require_setup"](this);
console.log(module.paths);
console.log("Loading native extensions...");
try {
loader.register_task(loader.Stage.JAVASCRIPT_INITIALIZING, {
name: "teaclient load adapters",
function: async () => {
/* all files which replaces a native driver */
try {
require("./version");
} catch(error) {
console.error("Failed to load version extension");
console.dir(error);
throw error;
}
try {
require("./app_backend");
} catch(error) {
console.error("Failed to load renderer app backend");
console.dir(error);
throw error;
}
try {
const helper = require("./icon-helper");
await helper.initialize();
} catch(error) {
console.error("Failed to load the icon helper extension");
console.dir(error);
throw error;
}
try {
require("./ppt");
} catch(error) {
console.error("Failed to load ppt");
console.dir(error);
throw error;
}
try {
require("./connection/ServerConnection");
} catch(error) {
console.error("Failed to load server connection extension");
console.dir(error);
throw error;
}
try {
require("./connection/FileTransfer");
} catch(error) {
console.error("Failed to load file transfer extension");
console.dir(error);
throw error;
}
try {
require("./dns/dns_resolver");
} catch(error) {
console.error("Failed to load dns extension");
console.dir(error);
throw error;
}
try {
require("./menu");
} catch(error) {
console.error("Failed to load menu extension");
console.dir(error);
throw error;
}
try {
require("./context-menu");
} catch(error) {
console.error("Failed to load context menu extension");
console.dir(error);
throw error;
}
} catch(error){
require("./app_backend");
require("./icon-helper").initialize();
} catch (error) {
console.log(error);
window.displayCriticalError("Failed to load native extensions: " + error);
throw error;
}
console.log("Loaded native extensions");
remote.getCurrentWindow().on('focus', () => remote.getCurrentWindow().flashFrame(false));
// remote.getCurrentWindow().flashFrame(true);
};
},
priority: 60
});
export async function initialize() { }

55
modules/renderer/menu.ts
View File

@ -1,17 +1,11 @@
import {class_to_image} from "./icon-helper";
window["require_setup"](module);
import * as electron from "electron";
//import {top_menu as dtop_menu, Icon} from "./imports/imports_shared";
/// <reference types="./imports/import_shared.d.ts" />
import dtop_menu = top_menu;
import * as mbar from "tc-shared/ui/frames/MenuBar";
import {Arguments, process_args} from "../shared/process-arguments";
namespace _top_menu {
import ipcRenderer = electron.ipcRenderer;
namespace native {
import ipcRenderer = electron.ipcRenderer;
import {Icon} from "tc-shared/FileManager";
namespace native {
import ipcRenderer = electron.ipcRenderer;
let _item_index = 1;
@ -26,7 +20,7 @@ namespace _top_menu {
}
abstract build() : electron.MenuItemConstructorOptions;
abstract items(): (dtop_menu.MenuItem | dtop_menu.HRItem)[];
abstract items(): (mbar.MenuItem | mbar.HRItem)[];
trigger_click() {
if(this._click)
@ -34,7 +28,7 @@ namespace _top_menu {
}
}
class NativeMenuItem extends NativeMenuBase implements dtop_menu.MenuItem {
class NativeMenuItem extends NativeMenuBase implements mbar.MenuItem {
private _items: (NativeMenuItem | NativeHrItem)[] = [];
private _label: string;
private _enabled: boolean = true;
@ -47,13 +41,13 @@ namespace _top_menu {
}
append_hr(): dtop_menu.HRItem {
append_hr(): mbar.HRItem {
const item = new NativeHrItem(this._handle);
this._items.push(item);
return item;
}
append_item(label: string): dtop_menu.MenuItem {
append_item(label: string): mbar.MenuItem {
const item = new NativeMenuItem(this._handle);
item.label(label);
this._items.push(item);
@ -65,7 +59,7 @@ namespace _top_menu {
return this;
}
delete_item(item: dtop_menu.MenuItem | dtop_menu.HRItem) {
delete_item(item: mbar.MenuItem | mbar.HRItem) {
const i_index = this._items.indexOf(item as any);
if(i_index < 0) return;
this._items.splice(i_index, 1);
@ -86,7 +80,7 @@ namespace _top_menu {
return "";
}
items(): (dtop_menu.MenuItem | dtop_menu.HRItem)[] {
items(): (mbar.MenuItem | mbar.HRItem)[] {
return this._items;
}
@ -117,7 +111,7 @@ namespace _top_menu {
}
}
class NativeHrItem extends NativeMenuBase implements dtop_menu.HRItem {
class NativeHrItem extends NativeMenuBase implements mbar.HRItem {
constructor(handle: NativeMenuBar) {
super(handle);
}
@ -129,7 +123,7 @@ namespace _top_menu {
}
}
items(): (dtop_menu.MenuItem | dtop_menu.HRItem)[] {
items(): (mbar.MenuItem | mbar.HRItem)[] {
return [];
}
}
@ -157,7 +151,7 @@ namespace _top_menu {
}
export class NativeMenuBar implements dtop_menu.MenuBarDriver {
export class NativeMenuBar implements mbar.MenuBarDriver {
private static _instance: NativeMenuBar;
private menu: electron.Menu;
@ -170,14 +164,14 @@ namespace _top_menu {
return this._instance;
}
append_item(label: string): dtop_menu.MenuItem {
append_item(label: string): mbar.MenuItem {
const item = new NativeMenuItem(this);
item.label(label);
this._items.push(item);
return item;
}
delete_item(item: dtop_menu.MenuItem) {
delete_item(item: mbar.MenuItem) {
const i_index = this._items.indexOf(item as any);
if(i_index < 0) return;
this._items.splice(i_index, 1);
@ -196,7 +190,7 @@ namespace _top_menu {
return this._items.map(e => e.build());
}
items(): dtop_menu.MenuItem[] {
items(): mbar.MenuItem[] {
return this._items;
}
@ -220,15 +214,11 @@ namespace _top_menu {
});
}
}
}
}
//Global variable
// @ts-ignore
top_menu.set_driver(native.NativeMenuBar.instance());
const call_basic_action = (name: string, ...args: any[]) => ipcRenderer.send('basic-action', name, ...args);
top_menu.native_actions = {
mbar.set_driver(native.NativeMenuBar.instance());
// @ts-ignore
mbar.native_actions = {
open_change_log() {
call_basic_action("open-changelog");
},
@ -250,8 +240,7 @@ namespace _top_menu {
},
show_dev_tools() { return process_args.has_flag(Arguments.DEV_TOOLS); }
};
}
};
export {};
const call_basic_action = (name: string, ...args: any[]) => ipcRenderer.send('basic-action', name, ...args);

108
modules/renderer/ppt.ts
View File

@ -1,15 +1,16 @@
window["require_setup"](module);
import {KeyEvent as NKeyEvent, RegisterCallback, UnregisterCallback} from "tc-native/ppt";
import {EventType, KeyEvent, KeyHook, SpecialKey} from "tc-shared/PPTListener";
import {tr} from "tc-shared/i18n/localize";
import {LogCategory} from "tc-shared/log";
import * as log from "tc-shared/log";
import {KeyEvent as NKeyEvent} from "teaclient_ppt";
namespace _ppt {
let key_listener: ((_: ppt.KeyEvent) => any)[] = [];
let key_listener: ((_: KeyEvent) => any)[] = [];
let native_ppt;
function listener_key(type: ppt.EventType, nevent: NKeyEvent) {
function listener_key(type: EventType, nevent: NKeyEvent) {
if(nevent.key_code === 'VoidSymbol' || nevent.key_code === 'error')
nevent.key_code = undefined; /* trigger event for state update */
let event: ppt.KeyEvent = {
let event: KeyEvent = {
type: type,
key: nevent.key_code,
@ -24,67 +25,66 @@ namespace _ppt {
for (const listener of key_listener)
listener && listener(event);
}
}
function native_keyhook(event: NKeyEvent) {
function native_keyhook(event: NKeyEvent) {
//console.log("Native event!: %o", event);
if(event.type == 0)
listener_key(ppt.EventType.KEY_PRESS, event);
listener_key(EventType.KEY_PRESS, event);
else if(event.type == 1)
listener_key(ppt.EventType.KEY_RELEASE, event);
listener_key(EventType.KEY_RELEASE, event);
else if(event.type == 2)
listener_key(ppt.EventType.KEY_TYPED, event);
listener_key(EventType.KEY_TYPED, event);
else
console.warn(tr("Received unknown native event: %o"), event);
}
export async function initialize() : Promise<void> {
native_ppt = require("teaclient_ppt");
}
export async function initialize() : Promise<void> {
register_key_listener(listener_hook);
native_ppt.RegisterCallback(native_keyhook);
}
RegisterCallback(native_keyhook);
}
export function finalize() {
export function finalize() {
unregister_key_listener(listener_hook);
native_ppt.UnregisterCallback(native_keyhook);
}
UnregisterCallback(native_keyhook);
}
export function register_key_listener(listener: (_: ppt.KeyEvent) => any) {
export function register_key_listener(listener: (_: KeyEvent) => any) {
key_listener.push(listener);
}
}
export function unregister_key_listener(listener: (_: ppt.KeyEvent) => any) {
key_listener.remove(listener);
}
export function unregister_key_listener(listener: (_: KeyEvent) => any) {
const index = key_listener.findIndex(e => e === listener);
if(index !== -1) key_listener.splice(index, 1);
}
let key_hooks: ppt.KeyHook[] = [];
let key_hooks: KeyHook[] = [];
interface CurrentState {
keys: {[code: string]:ppt.KeyEvent};
interface CurrentState {
keys: {[code: string]:KeyEvent};
special: { [key:number]:boolean };
}
let current_state: CurrentState = {
}
let current_state: CurrentState = {
special: []
} as any;
} as any;
let key_hooks_active: ppt.KeyHook[] = [];
let key_hooks_active: KeyHook[] = [];
function listener_hook(event: ppt.KeyEvent) {
if(event.type == ppt.EventType.KEY_TYPED)
function listener_hook(event: KeyEvent) {
if(event.type == EventType.KEY_TYPED)
return;
let old_hooks = [...key_hooks_active];
let new_hooks = [];
current_state.special[ppt.SpecialKey.ALT] = event.key_alt;
current_state.special[ppt.SpecialKey.CTRL] = event.key_ctrl;
current_state.special[ppt.SpecialKey.SHIFT] = event.key_shift;
current_state.special[ppt.SpecialKey.WINDOWS] = event.key_windows;
current_state.special[SpecialKey.ALT] = event.key_alt;
current_state.special[SpecialKey.CTRL] = event.key_ctrl;
current_state.special[SpecialKey.SHIFT] = event.key_shift;
current_state.special[SpecialKey.WINDOWS] = event.key_windows;
current_state[event.key_code] = undefined;
if(event.type == ppt.EventType.KEY_PRESS) {
if(event.type == EventType.KEY_PRESS) {
current_state[event.key_code] = event;
for(const hook of key_hooks) {
@ -95,7 +95,9 @@ namespace _ppt {
if(hook.key_windows != event.key_windows) continue;
new_hooks.push(hook);
if(!old_hooks.remove(hook) && hook.callback_press) {
const index = old_hooks.findIndex(e => e === hook);
if(index !== -1 && hook.callback_press) {
old_hooks.splice(index, 1);
hook.callback_press();
log.trace(LogCategory.GENERAL, tr("Trigger key press for %o!"), hook);
}
@ -115,23 +117,25 @@ namespace _ppt {
}
}
key_hooks_active = new_hooks;
}
}
export function register_key_hook(hook: ppt.KeyHook) {
export function register_key_hook(hook: KeyHook) {
key_hooks.push(hook);
}
}
export function unregister_key_hook(hook: ppt.KeyHook) {
key_hooks.remove(hook);
key_hooks_active.remove(hook);
}
export function unregister_key_hook(hook: KeyHook) {
let index;
export function key_pressed(code: string | ppt.SpecialKey) : boolean {
index = key_hooks.findIndex(e => e === hook);
if(index !== -1) key_hooks.splice(index, 1);
index = key_hooks_active.findIndex(e => e === hook);
if(index !== -1) key_hooks_active.splice(index, 1);
}
export function key_pressed(code: string | SpecialKey) : boolean {
if(typeof(code) === 'string')
return typeof(current_state[code]) === "object";
return current_state.special[code];
}
}
Object.assign(window["ppt"] || (window["ppt"] = {} as any), _ppt);
console.dir(_ppt);

106
modules/renderer/require-handler.ts Normal file
View File

@ -0,0 +1,106 @@
import * as path from "path";
import {remote} from "electron";
import * as electron from "electron";
import * as os from "os";
const Module = require("module");
interface ModuleOverride {
name?: string,
test: string | RegExp | ((request: string) => boolean);
callback: (this: string, request: string, parent?: NodeJS.Module) => any;
}
const overrides: ModuleOverride[] = [];
function proxied_load(request: string, parent?: NodeJS.Module) {
for(const override of overrides) {
let test_satisfied = false;
if(typeof override.test === "string") {
test_satisfied = override.test === request;
} else if(typeof override.test === "function") {
test_satisfied = override.test(request);
} else if(typeof override === "object") {
if(override.test instanceof RegExp)
test_satisfied = !!request.match(override.test);
}
if(test_satisfied) {
//console.log("Using override %s for %s", override.name || "unnamed", request);
return override.callback.apply(this, arguments);
}
}
//console.log("No override found for %s", request);
return proxied_load.original_load.apply(this, arguments);
}
function shared_backend_loader(request: string) {
if(!request.startsWith("tc-backend/")) throw "invalid target";
const target = request.substr(11);
return require(path.join(backend_root, target));
}
namespace proxied_load {
export let original_load: typeof Module.require;
}
let backend_root: string;
export function initialize(backend_root_: string) {
backend_root = backend_root_;
proxied_load.original_load = Module._load;
Module._load = proxied_load;
window["backend-loader"] = {
require: shared_backend_loader
};
}
overrides.push({
name: "tc-loader",
test: "tc-loader",
callback: () => window["loader"]
});
overrides.push({
name: "native loader",
test: /^tc-native\/[a-zA-Z_-]+$/,
callback: request => {
const name = request.substr(10);
const file_mapping = {
connection: "teaclient_connection.node",
ppt: "teaclient_ppt.node",
dns: "teaclient_dns.node"
};
if(typeof file_mapping[name] !== "string")
throw "unknown native module";
const app_path = (remote || electron).app.getAppPath();
const target_path = path.join(app_path, "native", "build", os.platform() + "_" + os.arch(), file_mapping[name]);
return require(target_path);
}
});
overrides.push({
name: "shared loader",
test: /^tc-shared\/.*/,
callback: request => {
const webpack_path = path.dirname("shared/js/" + request.substr(10)); //FIXME: Get the prefix from a variable!
const loader = require("tc-loader");
const mapping = loader.module_mapping().find(e => e.application === "client-app"); //FIXME: Variable name!
if(!mapping) throw "missing mapping";
const entries = mapping.modules.filter(e => e.context === webpack_path);
if(!entries.length) throw "unknown target path";
const basename = path.basename(request, path.extname(request));
const entry = entries.find(e => path.basename(e.resource, path.extname(e.resource)) === basename);
if(!entry) throw "unknown import";
return window["shared-require"](entry.id);
}
});

1
modules/renderer/version.ts
View File

@ -1,3 +1,4 @@
//FIXME!
namespace native {
const remote = require('electron').remote;
export async function client_version() : Promise<string> {

2
native/dns/exports/exports.d.ts vendored
View File

@ -1,4 +1,4 @@
declare module "teaclient_dns" {
declare module "tc-native/dns" {
export function resolve_cr(host: string, port: number, callback: (result: string | {host: string, port: number}) => any);
export function initialize();
}

2
native/ppt/exports/exports.d.ts vendored
View File

@ -1,4 +1,4 @@
declare module "teaclient_ppt" {
declare module "tc-native/ppt" {
enum KeyEventType {
PRESS = 0,
RELEASE = 1,

2
native/serverconnection/exports/exports.d.ts vendored
View File

@ -1,4 +1,4 @@
declare module "teaclient_connection" {
declare module "tc-native/connection" {
export enum ServerType {
UNKNOWN,
TEASPEAK,

19
native/serverconnection/src/connection/ProtocolHandler.cpp
View File

@ -139,6 +139,7 @@ void ProtocolHandler::execute_resend() {
this->handle->close_connection();
return;
}
log_trace(category::connection, tr("Resended {}"), resended);
auto socket = this->handle->get_socket();
if(socket) {
@ -164,6 +165,7 @@ void ProtocolHandler::progress_packet(const pipes::buffer_view &buffer) {
auto packet_type = packet->type();
auto packet_id = packet->packetId();
auto ordered = packet_type.type() == protocol::COMMAND || packet_type.type() == protocol::COMMAND_LOW;
log_trace(category::connection, tr("Received packet {} with id {}"), packet->type().name(), packet->packetId());
/* special handling */
if(packet_type.type() == protocol::INIT1) {
@ -253,6 +255,7 @@ void ProtocolHandler::progress_packet(const pipes::buffer_view &buffer) {
unique_lock queue_lock(read_queue.buffer_lock);
if(ordered) { /* ordered */
log_trace(category::connection, tr("Inserting packet {} with id {}"), packet->type().name(), packet->packetId());
if(!read_queue.insert_index(packet_id, std::forward<shared_ptr<ServerPacket>>(packet))) {
log_warn(category::connection, tr("Failed to insert ordered packet into queue. ({} | {} | {})"), packet_type.name(), read_queue.current_index(), packet_id);
}
@ -519,7 +522,7 @@ bool ProtocolHandler::create_datagram_packets(std::vector<pipes::buffer> &result
void ProtocolHandler::send_command(const ts::Command &cmd, const std::function<void(bool)> &ack_callback) {
auto data = cmd.build();
auto packet = make_shared<ClientPacket>(PacketTypeInfo::Command, pipes::buffer_view{data.data(), data.size()});
if(ack_callback) {
if(ack_callback || true) {
auto begin = chrono::system_clock::now();
packet->setListener(make_unique<threads::Future<bool>>());
packet->getListener()->waitAndGetLater([ack_callback, begin](bool f) {
@ -527,7 +530,7 @@ void ProtocolHandler::send_command(const ts::Command &cmd, const std::function<v
if(ack_callback)
ack_callback(f);
log_trace(category::connection, tr("Time needed for command: {}"), chrono::duration_cast<chrono::milliseconds>(end - begin).count());
log_trace(category::connection, tr("Time needed for command: {}ms. Success: {}"), chrono::duration_cast<chrono::milliseconds>(end - begin).count(), f);
});
}
packet->enable_flag(PacketFlag::NewProtocol);
@ -541,6 +544,18 @@ void ProtocolHandler::send_packet(const std::shared_ptr<ts::protocol::ClientPack
return;
}
{
if(packet->type() == protocol::PacketTypeInfo::Command && this->connection_state == connection_state::CONNECTED && false) {
ts::Command cmd{"whoami"};
auto data = cmd.build();
auto p1 = make_shared<ClientPacket>(PacketTypeInfo::Command, pipes::buffer_view{data.data(), data.size()});
if(!this->create_datagram_packets(result, p1))
log_error(category::connection, tr("failed to encode trap"));
std::reverse(result.begin(), result.end());
}
}
log_trace(category::connection, tr("Split up {} {} to {} packets. Ack waiting: {}"), packet->packetId(), packet->type().name(), result.size(), this->acknowledge_handler.awaiting_acknowledge());
auto socket = this->handle->get_socket();
if(!socket) {
log_error(category::connection, tr("Failed to get socket!"));

6
native/serverconnection/src/connection/ProtocolHandlerPackets.cpp
View File

@ -1,7 +1,5 @@
#include "ProtocolHandler.h"
#include "ServerConnection.h"
#include "Socket.h"
#include <protocol/buffers.h>
#include <thread>
#include <iostream>
#include <tomcrypt.h>
@ -21,7 +19,9 @@ using namespace ts;
void ProtocolHandler::handlePacketAck(const std::shared_ptr<ts::protocol::ServerPacket> &ack) {
string error;
log_trace(category::connection, tr("Handle packet acknowledge for {}"), be2le16(&ack->data()[0]));
this->acknowledge_handler.process_acknowledge(ack->type().type(), ack->data(), error);
if(!this->acknowledge_handler.process_acknowledge(ack->type().type(), ack->data(), error)) {
log_warn(category::connection, tr("Failed to handle acknowledge {}: {}"), be2le16(&ack->data()[0]) ,error);
}
}
void ProtocolHandler::handlePacketCommand(const std::shared_ptr<ts::protocol::ServerPacket> &packet) {

1
native/serverconnection/src/connection/ServerConnection.cpp
View File

@ -496,6 +496,7 @@ NAN_METHOD(ServerConnection::send_command) {
cmd[strobf("hwid").string()] = system_uuid(); /* we dont want anybody to patch this out */
}
}
log_trace(category::audio, tr("Sending data {}"), cmd.command());
this->protocol_handler->send_command(cmd);
auto end = chrono::system_clock::now();
}

245
package-lock.json generated
View File

@ -1,6 +1,6 @@
{
"name": "TeaClient",
"version": "1.4.3-2",
"version": "1.4.4",
"lockfileVersion": 1,
"requires": true,
"dependencies": {
@ -17,6 +17,18 @@
"got": "^9.6.0",
"sanitize-filename": "^1.6.2",
"sumchecker": "^3.0.1"
},
"dependencies": {
"fs-extra": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
"integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
"requires": {
"graceful-fs": "^4.2.0",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
}
}
}
},
"@sindresorhus/is": {
@ -383,6 +395,11 @@
"resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
"integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k="
},
"at-least-node": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
"integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg=="
},
"atob": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz",
@ -777,23 +794,104 @@
}
},
"chokidar": {
"version": "2.1.8",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz",
"integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==",
"version": "3.3.1",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.1.tgz",
"integrity": "sha512-4QYCEWOcK3OJrxwvyyAOxFuhpvOVCYkr33LPfFNBjAD/w3sEzWsp2BUOkI4l9bHvWioAd0rc6NlHUOEaWkTeqg==",
"dev": true,
"requires": {
"anymatch": "~3.1.1",
"braces": "~3.0.2",
"fsevents": "~2.1.2",
"glob-parent": "~5.1.0",
"is-binary-path": "~2.1.0",
"is-glob": "~4.0.1",
"normalize-path": "~3.0.0",
"readdirp": "~3.3.0"
},
"dependencies": {
"anymatch": {
"version": "3.1.1",
"resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.1.tgz",
"integrity": "sha512-mM8522psRCqzV+6LhomX5wgp25YVibjh8Wj23I5RPkPppSVSjyKD2A2mBJmWGa+KN7f2D6LNh9jkBCeyLktzjg==",
"dev": true,
"requires": {
"anymatch": "^2.0.0",
"async-each": "^1.0.1",
"braces": "^2.3.2",
"fsevents": "^1.2.7",
"glob-parent": "^3.1.0",
"inherits": "^2.0.3",
"is-binary-path": "^1.0.0",
"is-glob": "^4.0.0",
"normalize-path": "^3.0.0",
"path-is-absolute": "^1.0.0",
"readdirp": "^2.2.1",
"upath": "^1.1.1"
"picomatch": "^2.0.4"
}
},
"binary-extensions": {
"version": "2.0.0",
"resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.0.0.tgz",
"integrity": "sha512-Phlt0plgpIIBOGTT/ehfFnbNlfsDEiqmzE2KRXoX1bLIlir4X/MR+zSyBEkL05ffWgnRSf/DXv+WrUAVr93/ow==",
"dev": true
},
"braces": {
"version": "3.0.2",
"resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
"integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
"dev": true,
"requires": {
"fill-range": "^7.0.1"
}
},
"fill-range": {
"version": "7.0.1",
"resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
"integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
"dev": true,
"requires": {
"to-regex-range": "^5.0.1"
}
},
"fsevents": {
"version": "2.1.2",
"resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.2.tgz",
"integrity": "sha512-R4wDiBwZ0KzpgOWetKDug1FZcYhqYnUYKtfZYt4mD5SBz76q0KR4Q9o7GIPamsVPGmW3EYPPJ0dOOjvx32ldZA==",
"dev": true,
"optional": true
},
"glob-parent": {
"version": "5.1.1",
"resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
"integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
"dev": true,
"requires": {
"is-glob": "^4.0.1"
}
},
"is-binary-path": {
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
"dev": true,
"requires": {
"binary-extensions": "^2.0.0"
}
},
"is-number": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
"dev": true
},
"readdirp": {
"version": "3.3.0",
"resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.3.0.tgz",
"integrity": "sha512-zz0pAkSPOXXm1viEwygWIPSPkcBYjW1xU5j/JBh5t9bGCJwa6f9+BJa6VaB2g+b55yVrmXzqkyLf4xaWYM0IkQ==",
"dev": true,
"requires": {
"picomatch": "^2.0.7"
}
},
"to-regex-range": {
"version": "5.0.1",
"resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
"dev": true,
"requires": {
"is-number": "^7.0.0"
}
}
}
},
"chownr": {
@ -1489,9 +1587,9 @@
}
},
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ="
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
},
"ms": {
"version": "2.0.0",
@ -1868,9 +1966,9 @@
}
},
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
"dev": true
},
"ms": {
@ -2026,9 +2124,9 @@
}
},
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
"dev": true
},
"ms": {
@ -2089,6 +2187,18 @@
"ora": "^3.4.0",
"spawn-rx": "^3.0.0",
"yargs": "^14.2.0"
},
"dependencies": {
"fs-extra": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
"integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
"requires": {
"graceful-fs": "^4.2.0",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
}
}
}
},
"electron-winstaller": {
@ -2188,6 +2298,17 @@
"uuid": "^3.3.3"
},
"dependencies": {
"fs-extra": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
"integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
"dev": true,
"requires": {
"graceful-fs": "^4.2.0",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
}
},
"klaw": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/klaw/-/klaw-3.0.0.tgz",
@ -2553,13 +2674,30 @@
"integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="
},
"fs-extra": {
"version": "8.1.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
"integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
"version": "9.0.0",
"resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.0.0.tgz",
"integrity": "sha512-pmEYSk3vYsG/bF651KPUXZ+hvjpgWYw/Gc7W9NFUe3ZVLczKKWIij3IKpOrQcdw4TILtibFslZ0UmR8Vvzig4g==",
"requires": {
"at-least-node": "^1.0.0",
"graceful-fs": "^4.2.0",
"jsonfile": "^4.0.0",
"universalify": "^0.1.0"
"jsonfile": "^6.0.1",
"universalify": "^1.0.0"
},
"dependencies": {
"jsonfile": {
"version": "6.0.1",
"resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.0.1.tgz",
"integrity": "sha512-jR2b5v7d2vIOust+w3wtFKZIfpC2pnRmFAhAC/BuweZFQR8qZzxH1OyrQ10HmdVYiXWkYUqPVsz91cG7EL2FBg==",
"requires": {
"graceful-fs": "^4.1.6",
"universalify": "^1.0.0"
}
},
"universalify": {
"version": "1.0.0",
"resolved": "https://registry.npmjs.org/universalify/-/universalify-1.0.0.tgz",
"integrity": "sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug=="
}
}
},
"fs-minipass": {
@ -4232,9 +4370,9 @@
},
"dependencies": {
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ="
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
}
}
},
@ -4502,6 +4640,26 @@
"update-notifier": "^2.5.0"
},
"dependencies": {
"chokidar": {
"version": "2.1.8",
"resolved": "https://registry.npmjs.org/chokidar/-/chokidar-2.1.8.tgz",
"integrity": "sha512-ZmZUazfOzf0Nve7duiCKD23PFSCs4JPoYyccjUFF3aQkQadqBhfzhjkwBH2mNOG9cTBwhamM37EIsIkZw3nRgg==",
"dev": true,
"requires": {
"anymatch": "^2.0.0",
"async-each": "^1.0.1",
"braces": "^2.3.2",
"fsevents": "^1.2.7",
"glob-parent": "^3.1.0",
"inherits": "^2.0.3",
"is-binary-path": "^1.0.0",
"is-glob": "^4.0.0",
"normalize-path": "^3.0.0",
"path-is-absolute": "^1.0.0",
"readdirp": "^2.2.1",
"upath": "^1.1.1"
}
},
"debug": {
"version": "3.2.6",
"resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
@ -4628,9 +4786,9 @@
}
},
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ="
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
},
"ms": {
"version": "2.0.0",
@ -4981,6 +5139,12 @@
"resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz",
"integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns="
},
"picomatch": {
"version": "2.2.2",
"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.2.2.tgz",
"integrity": "sha512-q0M/9eZHzmr0AulXyPwNfZjtwZ/RBZlbN3K3CErVrk50T2ASYI7Bye0EvekFY3IP1Nt2DHu0re+V2ZHIpMkuWg==",
"dev": true
},
"pify": {
"version": "3.0.0",
"resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz",
@ -5143,9 +5307,9 @@
},
"dependencies": {
"minimist": {
"version": "1.2.0",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
"integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ="
"version": "1.2.5",
"resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
"integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
}
}
},
@ -6607,6 +6771,11 @@
"resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
"integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A=="
},
"v8-callsites": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/v8-callsites/-/v8-callsites-1.2.1.tgz",
"integrity": "sha1-PKTi3t9Q60ieNwVu1ksCVele84Y="
},
"validate-npm-package-license": {
"version": "3.0.4",
"resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz",

11
package.json
View File

@ -38,14 +38,14 @@
"asar": "^2.0.1",
"cmake-js": "^4.0.1",
"ejs": "^2.7.1",
"electron-installer-windows": "^1.1.1",
"electron-installer-windows": "^1.1.0",
"electron-packager": "8.7.2",
"electron-winstaller": "^2.7.0",
"electron-wix-msi": "^2.2.0",
"electron-wix-msi": "^2.1.1",
"nodemon": "^1.19.4",
"platform-dependent-modules": "0.0.14",
"rc": "^1.2.8",
"rcedit": "^1.1.2",
"rcedit": "^1.1.1",
"sass": "^1.23.2",
"typescript": "^3.7.2"
},
@ -62,7 +62,7 @@
"electron-rebuild": "^1.8.6",
"extend": "^3.0.2",
"extsprintf": "^1.4.0",
"fs-extra": "^8.1.0",
"fs-extra": "^9.0.0",
"http-signature": "^1.3.1",
"jquery": "^3.4.1",
"json-stringify-safe": "^5.0.1",
@ -80,7 +80,8 @@
"safer-buffer": "^2.1.2",
"sshpk": "^1.16.1",
"tar-stream": "^2.1.0",
"tough-cookie": "^3.0.1"
"tough-cookie": "^3.0.1",
"v8-callsites": "latest"
},
"config": {
"platformDependentModules": {

7
tsconfig.json
View File

@ -6,7 +6,12 @@
"moduleResolution": "node",
"rootDirs": [
"modules"
]
],
"baseUrl": ".",
"paths": {
"tc-shared/*": ["imports/shared-app/*"],
"tc-loader": ["imports/loader"]
}
},
"exclude": [
"node_modules",