');
30 |
31 | for (let column of columns) {
32 | let cellElement = $('');
33 |
34 | cellElement.text(column);
35 |
36 | cellElement.appendTo(rowElement);
37 | }
38 |
39 | rowElement[position](this.tableElement);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/template/about.hbs:
--------------------------------------------------------------------------------
1 | JavaScript XMPP Chat
2 |
3 | Version: {{version}}
4 | Build date: {{date}}
5 | www.jsxc.org
6 |
7 |
8 | Released under the MIT license
9 |
10 |
11 | Real-time chat app for {{appName}} and more.
12 |
13 |
14 | {{t "Credits"}}: David English (Ringtone),
15 | CameronMusic (Ping),
16 | Picol (Fullscreen icon), Jabber Software Foundation (Jabber lightbulb logo)
17 |
18 |
19 | {{t "Libraries"}}:
20 | {{dependencies}}
21 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/template/multiUserInvite.hbs:
--------------------------------------------------------------------------------
1 | {{t "Invite_user"}}
2 | {{t "muc_invite_explanation"}}
3 |
23 |
--------------------------------------------------------------------------------
/images/download_icon_black.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 | "defaultSeverity": "error",
3 | "extends": [
4 | "tslint:recommended"
5 | ],
6 | "jsRules": {},
7 | "rules": {
8 | "quotemark": [true, "single"],
9 | "prefer-const": false,
10 | "trailing-comma": false,
11 | "semicolon": false,
12 | "ordered-imports": false,
13 | "member-ordering": false,
14 | "arrow-parens": false,
15 | "no-angle-bracket-type-assertion": false,
16 | "comment-format": false,
17 | "max-line-length": false,
18 | "only-arrow-functions": false,
19 | "unified-signatures": false,
20 | "interface-name": true,
21 | "object-literal-sort-keys": false,
22 | "max-classes-per-file": false,
23 | "no-console": false,
24 | "no-bitwise": false,
25 | "no-shadowed-variable": false,
26 | "no-var-requires": false,
27 | "no-unused-expression": [true, "allow-new"],
28 | "forin": false,
29 | "no-empty": false,
30 | "ban-types": false
31 | },
32 | "rulesDirectory": []
33 | }
34 |
--------------------------------------------------------------------------------
/images/download_icon_white.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/plugins/omemo/vendor/SignalStore.interface.ts:
--------------------------------------------------------------------------------
1 |
2 | export interface IIdentityKeyPair { privKey?: ArrayBuffer, pubKey: ArrayBuffer }
3 | export interface IPreKeyPair { pubKey, privKey }
4 | export interface ISignedPreKeyPair { signature, pubKey, privKey }
5 |
6 | interface ISignalStore {
7 | Direction: { SENDING: number, RECEIVING: number }
8 |
9 | getIdentityKeyPair(): Promise;
10 |
11 | getLocalRegistrationId(): Promise;
12 |
13 | isTrustedIdentity(addressName: string, identityKey: ArrayBuffer, direction: number): Promise;
14 |
15 | saveIdentity(address: string, identityKey: ArrayBuffer): Promise;
16 |
17 | loadPreKey(keyId: number): Promise;
18 |
19 | removePreKey(keyId: number): Promise;
20 |
21 | loadSignedPreKey(keyId: number): Promise;
22 |
23 | loadSession(address: string): Promise;
24 |
25 | storeSession(identifier: string, session: string): Promise;
26 | }
27 |
28 | export default ISignalStore;
29 |
--------------------------------------------------------------------------------
/src/connection/xmpp/handlers/multiUser/Presence.ts:
--------------------------------------------------------------------------------
1 | import Log from '../../../../util/Log'
2 | import JID from '../../../../JID'
3 | import MultiUserContact from '../../../../MultiUserContact'
4 | import AbstractHandler from '../../AbstractHandler'
5 | import MultiUserPresenceProcessor from './PresenceProcessor'
6 |
7 | export default class extends AbstractHandler {
8 | public processStanza(stanza: Element): boolean {
9 | Log.debug('onMultiUserPresence', stanza);
10 |
11 | let from = new JID($(stanza).attr('from'));
12 | let type = $(stanza).attr('type');
13 |
14 | let xElement = $(stanza).find('x[xmlns="http://jabber.org/protocol/muc#user"]');
15 | let multiUserContact = this.account.getContact(from);
16 |
17 | if (!(multiUserContact instanceof MultiUserContact) || xElement.length === 0) {
18 | return this.PRESERVE_HANDLER;
19 | }
20 |
21 | let nickname = from.resource;
22 |
23 | new MultiUserPresenceProcessor(multiUserContact, xElement, nickname, type);
24 |
25 | return this.PRESERVE_HANDLER;
26 | }
27 | }
28 |
--------------------------------------------------------------------------------
/src/plugins/omemo/vendor/SessionCipher.ts:
--------------------------------------------------------------------------------
1 | import { SignalSessionCipher, SignalAddress } from './Signal';
2 | import Address from './Address';
3 | import Store from '../lib/Store';
4 | import { ICiphertext } from '../model/EncryptedDeviceMessage';
5 |
6 | export class SessionCipher {
7 | private signalSessionCipher;
8 |
9 | constructor(address: Address, store: Store) {
10 | let signalAddress = new SignalAddress(address.getName(), address.getDeviceId());
11 |
12 | this.signalSessionCipher = new SignalSessionCipher(store.getSignalStore(), signalAddress);
13 | }
14 |
15 | public decryptPreKeyMessage(ciphertext): Promise {
16 | return this.signalSessionCipher.decryptPreKeyWhisperMessage(ciphertext, 'binary');
17 | }
18 |
19 | public decryptMessage(ciphertext): Promise {
20 | return this.signalSessionCipher.decryptWhisperMessage(ciphertext, 'binary');
21 | }
22 |
23 | public encryptMessage(plaintext): Promise {
24 | return this.signalSessionCipher.encrypt(plaintext, 'binary');
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/images/megaphone_icon_black.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "allowSyntheticDefaultImports": true,
3 | "allowJs": true,
4 | "compilerOptions": {
5 | "baseUrl": "src",
6 | "paths": {
7 | "emojione": ["lib/emojione/lib/js/emojione.js"],
8 | "@connection/*": ["connection/*"],
9 | "@ui/*": ["ui/*"],
10 | "@util/*": ["util/*"],
11 | "@vendor/*": ["vendor/*"],
12 | "@src/*": ["./*"],
13 | "@interactjs/interactjs/*": ["../node_modules/@interactjs/interact/*"]
14 | },
15 | "moduleResolution": "node",
16 | "module": "commonjs",
17 | "outDir": "./dist",
18 | "target": "es5",
19 | "lib": ["dom", "es2015", "es2015.promise", "es5"],
20 | "noUnusedLocals": true,
21 | "downlevelIteration": true
22 | },
23 | "include": [
24 | "./src/**/*.ts",
25 | "./template/*.hbs",
26 | "./*.d.ts",
27 | "./test/**/*.ts"
28 | ],
29 | "exclude": [
30 | "node_modules",
31 | "typings"
32 | ],
33 | "files": [
34 | "custom.d.ts"
35 | ]
36 | }
37 |
--------------------------------------------------------------------------------
/src/ui/DialogPage.ts:
--------------------------------------------------------------------------------
1 | import Navigation from './DialogNavigation'
2 |
3 | export default abstract class Page {
4 | private element: JQuery;
5 |
6 | constructor(protected navigation: Navigation, private title: string) {
7 |
8 | }
9 |
10 | public getDOM(): JQuery {
11 | if (!this.element) {
12 | this.generateDOM();
13 | }
14 |
15 | return this.element;
16 | }
17 |
18 | private generateDOM() {
19 | this.element = $('');
20 | this.element.addClass('jsxc-page');
21 |
22 | let legendElement = $(' ');
23 | legendElement.addClass('jsxc-page__headline')
24 | legendElement.text(this.title);
25 |
26 | if (this.navigation.canGoBack()) {
27 | legendElement.addClass('jsxc-clickable'); //@REVIEW
28 | legendElement.on('click', () => {
29 | this.navigation.goBack();
30 | });
31 | }
32 |
33 | legendElement.appendTo(this.element);
34 |
35 | this.element.append(this.generateContentElement());
36 | }
37 |
38 | protected abstract generateContentElement(): JQuery | JQuery[]
39 | }
40 |
--------------------------------------------------------------------------------
/src/LinkHandlerGeo.ts:
--------------------------------------------------------------------------------
1 | import { ILinkHandler } from './LinkHandler.interface';
2 | import Location from '@util/Location';
3 |
4 | export default class LinkHandlerGeo implements ILinkHandler {
5 | private static instance: LinkHandlerGeo;
6 |
7 | public static get(): LinkHandlerGeo {
8 | if (!LinkHandlerGeo.instance) {
9 | LinkHandlerGeo.instance = new LinkHandlerGeo();
10 | }
11 |
12 | return LinkHandlerGeo.instance;
13 | }
14 |
15 | public detect(element: JQuery) {
16 | element.find('[href^="geo:"]').each(function() {
17 | let uri = $(this).attr('href');
18 | let coords = Location.parseGeoUri(uri);
19 | let link = Location.locationToLink(coords.latitude, coords.longitude);
20 | let label = 'OSM: ' + Location.ddToDms(coords.latitude, coords.longitude);
21 |
22 | if (coords.accuracy) {
23 | label += ' (±' + (Math.round(coords.accuracy * 10) / 10) + 'm)';
24 | }
25 |
26 | $(this).attr('href', link);
27 | $(this).text(label);
28 | $(this).addClass('jsxc-geo');
29 | })
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/src/CONST.ts:
--------------------------------------------------------------------------------
1 | import incomingMessageSoundFile from '../sound/incomingMessage.mp3';
2 | import incomingCallSoundFile from '../sound/Rotary-Phone6.mp3';
3 | import noticeSoundFile from '../sound/Ping1.mp3';
4 |
5 | export let NOTIFICATION_DEFAULT = 'default';
6 | export let NOTIFICATION_GRANTED = 'granted';
7 | export let NOTIFICATION_DENIED = 'denied';
8 | export let STATUS = ['offline', 'dnd', 'xa', 'away', 'chat', 'online'];
9 | export let SOUNDS = {
10 | MSG: ( incomingMessageSoundFile),
11 | CALL: ( incomingCallSoundFile),
12 | NOTICE: ( noticeSoundFile)
13 | };
14 | export let REGEX = {
15 | JID: new RegExp('\\b[^"&\'\\/:<>@\\s]+@[\\w-_.]+\\b', 'ig'),
16 | URL: new RegExp(/(aesgcm:\/\/|https?:\/\/|www\.)[^\s<>'"]+/gi),
17 | GEOURI: new RegExp(/geo:(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)(?:,-?\d+(?:\.\d+)?)?(?:;crs=[\w-]+)?(?:;u=(\d+(?:\.\d+)?))?(?:;[\w-]+=(?:[\w-_.!~*'()]|%[\da-f][\da-f])+)*/, 'g'),
18 | };
19 | export let NS = {
20 | CARBONS: 'urn:xmpp:carbons:2',
21 | FORWARD: 'urn:xmpp:forward:0'
22 | };
23 | export let HIDDEN = 'hidden';
24 | export let SHOWN = 'shown';
25 |
--------------------------------------------------------------------------------
/template/multiUserInvitation.hbs:
--------------------------------------------------------------------------------
1 | {{t "muc_invitation"}}
2 | {{t "muc_invitation_explanation"}}
3 |
29 |
--------------------------------------------------------------------------------
/images/smiley.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/api/index.ts:
--------------------------------------------------------------------------------
1 | import { testBOSHServer } from './v1/testBOSHServer';
2 | import Client from '../Client';
3 | import * as v1 from './v1'
4 | import { AbstractPlugin } from '@src/plugin/AbstractPlugin';
5 | import { EncryptionPlugin } from '@src/plugin/EncryptionPlugin';
6 |
7 | export default class JSXC {
8 | public static readonly version = __VERSION__;
9 |
10 | public static readonly testBOSHServer = testBOSHServer;
11 |
12 | public static readonly register = v1.register;
13 |
14 | public static readonly AbstractPlugin = AbstractPlugin;
15 |
16 | public static readonly AbstractEncryptionPlugin = EncryptionPlugin;
17 |
18 | public static readonly jQuery = $;
19 |
20 | private static initialized = false;
21 |
22 | public numberOfCachedAccounts: number;
23 |
24 | public version: string = __VERSION__;
25 |
26 | constructor(options) {
27 | if (JSXC.initialized) {
28 | throw new Error('JSXC was already initialized');
29 | }
30 |
31 | JSXC.initialized = true;
32 |
33 | this.numberOfCachedAccounts = Client.init(options);
34 |
35 | Object.assign(this, v1);
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
1 | ---
2 | name: Bug report
3 | about: Create a report to help us improve
4 | title: ''
5 | labels: ''
6 | assignees: ''
7 |
8 | ---
9 |
10 | ### Expected behavior
11 |
12 | ### Actual behavior
13 |
14 | ### Steps to reproduce the behavior
15 | 1.
16 | 2.
17 | 3.
18 |
19 | ### Environment
20 | - **JSXC version:**
21 | - **Host system and version:**
22 | - **Browser vendor and version:**
23 | - **Any browser plugins enabled?**
24 | - **XMPP server vendor and version:**
25 | - **Is your XMPP server working with other clients as expected?**
26 |
27 | ### Logs
28 | #### Javascript
29 |
30 | ```
31 | ```
32 |
33 | #### JSXC
34 |
35 |
36 | ```
37 | ```
38 |
39 | #### XMPP
40 |
41 | ```
42 | ```
43 |
44 | #### Host
45 |
46 | ```
47 | ```
48 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2018 Klaus Herberth
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 |
--------------------------------------------------------------------------------
/images/filetypes/folder-shared.svg:
--------------------------------------------------------------------------------
1 |
2 |
5 |
--------------------------------------------------------------------------------
/src/connection/services/Disco.ts:
--------------------------------------------------------------------------------
1 | import AbstractService from './AbstractService'
2 | import { IJID } from '../../JID.interface'
3 | import * as NS from '../xmpp/namespace'
4 | import { $iq } from '../../vendor/Strophe'
5 |
6 | export default class Disco extends AbstractService {
7 | public getDiscoInfo(jid: IJID, node?: string): Promise {
8 | let attrs = {
9 | xmlns: NS.get('DISCO_INFO'),
10 | node: null
11 | };
12 |
13 | if (typeof node === 'string' && node.length > 0) {
14 | attrs.node = node;
15 | }
16 |
17 | let iq = $iq({
18 | to: jid.full,
19 | type: 'get'
20 | }).c('query', attrs);
21 |
22 | return this.sendIQ(iq);
23 | }
24 |
25 | public getDiscoItems(jid: IJID, node?: string): Promise {
26 | let attrs = {
27 | xmlns: NS.get('DISCO_ITEMS'),
28 | node: null
29 | };
30 |
31 | if (typeof node === 'string' && node.length > 0) {
32 | attrs.node = node;
33 | }
34 |
35 | let iq = $iq({
36 | to: jid.full,
37 | type: 'get'
38 | }).c('query', attrs);
39 |
40 | return this.sendIQ(iq);
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/src/connection/xmpp/handlers/multiUser/XMessage.ts:
--------------------------------------------------------------------------------
1 | import JID from '../../../../JID'
2 | import AbstractHandler from '../../AbstractHandler'
3 | import { TYPE as NOTICETYPE, FUNCTION as NOTICEFUNCTION } from '../../../../Notice'
4 |
5 | export default class extends AbstractHandler {
6 | public processStanza(stanza: Element) {
7 | let from = new JID($(stanza).attr('from'));
8 | let xElement = $(stanza).find('x[xmlns="http://jabber.org/protocol/muc#user"]');
9 |
10 | let inviteElement = xElement.find('invite');
11 |
12 | if (inviteElement.length === 1) {
13 | let host = new JID(inviteElement.attr('from'));
14 | let reason = inviteElement.find('reason').text();
15 | let password = inviteElement.find('password').text();
16 |
17 | this.account.getNoticeManager().addNotice({
18 | title: 'Invitation',
19 | description: `for ${from.bare}`,
20 | type: NOTICETYPE.invitation,
21 | fnName: NOTICEFUNCTION.multiUserInvitation,
22 | fnParams: ['direct', host.bare, from.bare, reason, password, this.account.getUid()]
23 | });
24 | }
25 |
26 | return this.PRESERVE_HANDLER;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/ui/dialogs/selection.ts:
--------------------------------------------------------------------------------
1 | import Dialog from '../Dialog'
2 |
3 | let selectionTemplate = require('../../../template/selection.hbs');
4 |
5 | interface ISelectionDialogOptions {
6 | header?: string,
7 | message?: string,
8 | primary?: {
9 | label?: string,
10 | cb: () => any
11 | },
12 | option?: {
13 | label?: string,
14 | cb: () => any
15 | },
16 | id?: string
17 | }
18 |
19 | export default function(options: ISelectionDialogOptions) {
20 | let content = selectionTemplate({
21 | ...options,
22 | hasPrimary: options.primary && typeof options.primary.cb === 'function',
23 | hasOption: options.option && typeof options.option.cb === 'function',
24 | });
25 |
26 | let dialog = new Dialog(content, true);
27 | let dom = dialog.open();
28 |
29 | if (options.id) {
30 | dom.attr('data-selection-id', options.id);
31 | }
32 |
33 | dom.find('.jsxc-button--primary').click(function() {
34 | options.primary.cb.call(this, arguments);
35 |
36 | dialog.close();
37 | });
38 | dom.find('.jsxc-button--default').click(function() {
39 | options.option.cb.call(this, arguments);
40 |
41 | dialog.close();
42 | });
43 | }
44 |
--------------------------------------------------------------------------------
/src/util/HookRepository.ts:
--------------------------------------------------------------------------------
1 |
2 | export default class HookRepository {
3 | private hooks = {};
4 |
5 | public registerHook(eventName: string, func: T) {
6 | if (!this.hooks[eventName]) {
7 | this.hooks[eventName] = [];
8 | }
9 |
10 | this.hooks[eventName].push(func);
11 | }
12 |
13 | public removeHook(eventName: string, func: T) {
14 | let eventNameList = this.hooks[eventName] || [];
15 |
16 | if (eventNameList.indexOf(func) > -1) {
17 | eventNameList = $.grep(eventNameList, function(i) {
18 | return func !== i;
19 | });
20 | }
21 |
22 | this.hooks[eventName] = eventNameList;
23 | }
24 |
25 | public trigger(targetEventName: string, ...args) {
26 | let hooks = this.hooks;
27 |
28 | let eventNames = Object.keys(hooks);
29 | eventNames.forEach(function(eventName) {
30 | if (targetEventName === eventName || targetEventName.indexOf(eventName + ':') === 0) {
31 | let eventNameHooks = hooks[eventName] || [];
32 | eventNameHooks.forEach(function(hook) {
33 | hook.apply({}, args);
34 | });
35 | }
36 | });
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/test/Client.ts:
--------------------------------------------------------------------------------
1 | import JID from '../src/JID'
2 | import Account from './AccountStub'
3 | import { IPlugin as PluginInterface } from '../src/plugin/AbstractPlugin'
4 |
5 | export default class Client {
6 | private static account = new Account();
7 |
8 | public static init() { }
9 |
10 | public static addConnectionPlugin(plugin: PluginInterface) { }
11 |
12 | public static addPreSendMessageHook(hook: (Message, Builder) => void, position?: number) { }
13 |
14 | public static hasFocus() { }
15 |
16 | public static isExtraSmallDevice(): boolean {
17 | return false;
18 | }
19 |
20 | public static isDebugMode(): boolean {
21 | return false;
22 | }
23 |
24 | public static getStorage() { }
25 |
26 | public static getAccout(jid: JID): Account;
27 | public static getAccout(uid?: string): Account;
28 | public static getAccout(): Account {
29 | return Client.account;
30 | }
31 |
32 | public static createAccount(boshUrl: string, jid: string, sid: string, rid: string);
33 | public static createAccount(boshUrl: string, jid: string, password: string);
34 | public static createAccount() {
35 |
36 | }
37 |
38 | public static removeAccount(account: Account) {
39 |
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/scss/partials/_avatar.scss:
--------------------------------------------------------------------------------
1 | .jsxc-avatar {
2 | background-color: $avatar-bg;
3 | background-position: center center;
4 | background-repeat: no-repeat;
5 | background-size: cover;
6 | border-radius: 50%;
7 | color: $avatar-color;
8 | float: left;
9 | font-family: inherit;
10 | font-size: 30px;
11 | font-weight: bold;
12 | height: 36px;
13 | line-height: 36px;
14 | margin: 0 5px;
15 | position: relative;
16 | text-align: center;
17 | width: 36px;
18 |
19 | img {
20 | display: block;
21 | height: 25px;
22 | left: 0;
23 | position: absolute;
24 | top: 0;
25 | width: 25px;
26 | }
27 |
28 | &::before {
29 | border: 2px solid $roster-bg;
30 | left: -6px;
31 | position: absolute;
32 | top: -2px;
33 | }
34 |
35 | &--loading::after {
36 | animation: jsxc-rotate 1s infinite;
37 | border: 10px solid rgba(255, 255, 255, 0.7);
38 | border-left-color: rgba(0, 0, 0, 0.5);
39 | border-radius: 50%;
40 | border-right-color: rgba(0, 0, 0, 0.5);
41 | box-sizing: border-box;
42 | content: "";
43 | display: block;
44 | height: 20px;
45 | left: 50%;
46 | margin-left: -10px;
47 | margin-top: -10px;
48 | position: absolute;
49 | top: 50%;
50 | width: 20px;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/StateMachine.ts:
--------------------------------------------------------------------------------
1 | import Log from './util/Log'
2 |
3 | export default class StateMachine {
4 | public static STATE = {
5 | INITIATING: 0,
6 | PREVCONFOUND: 1,
7 | SUSPEND: 2,
8 | TRYTOINTERCEPT: 3,
9 | INTERCEPTED: 4,
10 | ESTABLISHING: 5,
11 | READY: 6
12 | };
13 |
14 | public static UISTATE = {
15 | STANDBY: 0,
16 | INITIATING: 1,
17 | READY: 2,
18 | }
19 |
20 | private static currentState;
21 | private static currentUIState = StateMachine.UISTATE.STANDBY;
22 |
23 | public static changeState(state: number) {
24 | StateMachine.currentState = state;
25 |
26 | Log.debug('State changed to ' + Object.keys(StateMachine.STATE)[state]);
27 |
28 | $(document).trigger('stateChange.jsxc', state);
29 | }
30 |
31 | public static getState(): number {
32 | return StateMachine.currentState;
33 | }
34 |
35 | public static changeUIState(state: number) {
36 | StateMachine.currentUIState = state;
37 |
38 | Log.debug('UI State changed to ' + Object.keys(StateMachine.UISTATE)[state]);
39 |
40 | $(document).trigger('stateUIChange.jsxc', state);
41 | }
42 |
43 | public static getUIState(): number {
44 | return StateMachine.currentUIState;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/bootstrap/plugins.ts:
--------------------------------------------------------------------------------
1 | import Client from '../Client'
2 | import OTRPlugin from '../plugins/otr/Plugin'
3 | import ReceiptPlugin from '../plugins/MessageDeliveryReceiptsPlugin'
4 | import NotificationPlugin from '../plugins/NotificationPlugin'
5 | import MeCommandPlugin from '../plugins/MeCommandPlugin'
6 | import MessageArchiveManagementPlugin from '../plugins/mam/Plugin'
7 | import ChatStatePlugin from '../plugins/chatState/ChatStatePlugin'
8 | import HttpUploadPlugin from '../plugins/httpUpload/HttpUploadPlugin'
9 | import AvatarVCardPlugin from '../plugins/AvatarVCardPlugin'
10 | import CarbonsPlugin from '../plugins/MessageCarbonsPlugin'
11 | import OMEMOPlugin from '../plugins/omemo/Plugin'
12 | import BookmarksPlugin from '@src/plugins/bookmarks/BookmarksPlugin';
13 | import ChatMarkersPlugin from '@src/plugins/chatMarkers/ChatMarkersPlugin'
14 |
15 | Client.addPlugin(OTRPlugin);
16 | Client.addPlugin(OMEMOPlugin);
17 | Client.addPlugin(ReceiptPlugin);
18 | Client.addPlugin(NotificationPlugin);
19 | Client.addPlugin(MeCommandPlugin);
20 | Client.addPlugin(MessageArchiveManagementPlugin);
21 | Client.addPlugin(ChatStatePlugin);
22 | Client.addPlugin(HttpUploadPlugin);
23 | Client.addPlugin(AvatarVCardPlugin);
24 | Client.addPlugin(CarbonsPlugin);
25 | Client.addPlugin(BookmarksPlugin);
26 | Client.addPlugin(ChatMarkersPlugin);
27 |
--------------------------------------------------------------------------------
/src/Migration.ts:
--------------------------------------------------------------------------------
1 | import Storage from './Storage';
2 | import Log from '@util/Log';
3 |
4 | const VERSION_KEY = 'version';
5 |
6 | export default class Migration {
7 | public static run(currentVersion: string, storage: Storage) {
8 | new Migration(currentVersion, storage);
9 | }
10 |
11 | private keys: string[];
12 |
13 | private constructor(currentVersion: string, private storage: Storage) {
14 | let lastVersion = storage.getItem(VERSION_KEY);
15 |
16 | if (lastVersion !== currentVersion) {
17 | Log.debug('Apply migrations');
18 |
19 | this.keys = Object.keys(storage.getBackend());
20 |
21 | this.runV3Migration();
22 |
23 | storage.setItem(VERSION_KEY, currentVersion);
24 | }
25 | }
26 |
27 | private runV3Migration() {
28 | let backend = this.storage.getBackend();
29 |
30 | if (!backend.getItem('jsxc:version')) {
31 | return;
32 | }
33 |
34 | Log.debug('Run migration for 3.x');
35 |
36 | this.keys.forEach(key => {
37 | let matches = key.match(/^jsxc:([^:]+):key$/);
38 |
39 | if (matches) {
40 | let newKey = this.storage.generateKey(matches[1], 'plugin', 'otr', 'key');
41 |
42 | this.storage.setItem(newKey, backend.getItem(key));
43 | }
44 | });
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/plugins/omemo/vendor/SessionBuilder.ts:
--------------------------------------------------------------------------------
1 | import { SignalSessionBuilder, ISignalBundleObject, SignalAddress } from './Signal';
2 | import Address from './Address';
3 | import Store from '../lib/Store';
4 | import Bundle from '../lib/Bundle';
5 |
6 | export class SessionBuilder {
7 | private signalSessionBuilder;
8 |
9 | constructor(address: Address, store: Store) {
10 | let signalAddress = new SignalAddress(address.getName(), address.getDeviceId());
11 | this.signalSessionBuilder = new SignalSessionBuilder(store.getSignalStore(), signalAddress);
12 | }
13 |
14 | public processPreKey(bundle: Bundle): Promise<[void, boolean]> {
15 | let preKey = bundle.getRandomPreKey();
16 | let signedPreKey = bundle.getSignedPreKey();
17 |
18 | let signalBundle: ISignalBundleObject = {
19 | identityKey: bundle.getIdentityKey().getPublic(),
20 | registrationId: 0,
21 | preKey: {
22 | keyId: preKey.getId(),
23 | publicKey: preKey.getPublic(),
24 | },
25 | signedPreKey: {
26 | keyId: signedPreKey.getId(),
27 | publicKey: signedPreKey.getPublic(),
28 | signature: signedPreKey.getSignature(),
29 | }
30 | };
31 |
32 | return this.signalSessionBuilder.processPreKey(signalBundle);
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/scripts/prepare-commit-msg.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs');
2 | const path = require('path');
3 | const lintConfig = require('../.commitlintrc.json');
4 |
5 | const allowedTypes = lintConfig.rules['type-enum'][2];
6 | const params = (process.env.HUSKY_GIT_PARAMS || '').split(' ');
7 |
8 | const getCommitMessage = () => {
9 | return `
10 |
11 | # Please enter the commit message for your changes. Lines starting
12 | # with '#' will be ignored, and an empty message aborts the commit.
13 | # In this project we use standardized commit messages. Please adhere
14 | # to the following syntax.
15 | #
16 | # :
17 | #
18 | # [optional body]
19 | #
20 | # [optional footer]
21 | #
22 | # Allowed types are: ${allowedTypes.join(', ')}.
23 | #
24 | # If you fix an issue please add 'fix #NUMBER' to the footer and NOT
25 | # to the description.
26 | #
27 | # See https://www.conventionalcommits.org/ for more details.`;
28 | };
29 |
30 | // only apply custom messages when run as a standalone `git commit`
31 | // i.e. ignore `--amend` commits, merges, or commits with `-m`
32 | if (params.length > 1) {
33 | process.exit();
34 | }
35 |
36 | if (!params[0]) {
37 | console.log(getCommitMessage());
38 |
39 | process.exit();
40 | }
41 |
42 | const TARGET = path.resolve(process.cwd(), params[0]);
43 | fs.writeFileSync(TARGET, `${getCommitMessage()}`);
44 |
--------------------------------------------------------------------------------
/src/util/Pipe.ts:
--------------------------------------------------------------------------------
1 |
2 | const MAX_PRIORITY = 100;
3 | const MIN_PRIORITY = 0;
4 |
5 | type Params = any[];
6 |
7 | export default class Pipe {
8 |
9 | private pipe = [];
10 |
11 | constructor() {
12 |
13 | }
14 |
15 | public addProcessor(processor: (...args: params) => Promise | params, priority: number = 50) {
16 | if (isNaN(priority) || priority < MIN_PRIORITY || priority > MAX_PRIORITY) {
17 | throw new Error('Priority has to be between 0 and 100');
18 | }
19 |
20 | if (typeof this.pipe[priority] === 'undefined') {
21 | this.pipe[priority] = [];
22 | }
23 |
24 | this.pipe[priority].push(processor);
25 | }
26 |
27 | public run(...args: params): Promise {
28 | let chain = Promise.resolve(args);
29 |
30 | this.pipe.forEach((processors) => {
31 | if (typeof processors === 'undefined' || processors === null || typeof processors !== 'object' || !processors.length) {
32 | return;
33 | }
34 |
35 | processors.forEach((processor) => {
36 | chain = chain.then((args2: any[]) => {
37 | return processor.apply(this, args2);
38 | });
39 | });
40 | });
41 |
42 | return chain;
43 | }
44 |
45 | public destroy() {
46 | this.pipe = [];
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/src/connection/xmpp/handlers/headlineMessage.ts:
--------------------------------------------------------------------------------
1 | import AbstractHandler from '../AbstractHandler'
2 | import JID from '../../../JID'
3 | import Translation from '../../../util/Translation'
4 | import { TYPE, FUNCTION } from '../../../Notice'
5 |
6 | export default class extends AbstractHandler {
7 | public processStanza(stanza: Element) {
8 | let fromJid = new JID(stanza.getAttribute('from'));
9 | let connection = this.account.getConnection();
10 | let myJid = connection.getJID();
11 |
12 | if (!fromJid.isServer) {
13 | if (!this.account.getContact(fromJid)) {
14 | return this.PRESERVE_HANDLER;
15 | }
16 | } else if (fromJid.domain !== myJid.domain) {
17 | return this.PRESERVE_HANDLER;
18 | }
19 |
20 | if ($(stanza).find('body:first').length === 0) {
21 | return this.PRESERVE_HANDLER;
22 | }
23 |
24 | let subject = $(stanza).find('subject:first').text() || Translation.t('Notification');
25 | let body = $(stanza).find('body:first').text();
26 |
27 | this.account.getNoticeManager().addNotice({
28 | title: subject,
29 | description: body,
30 | fnName: FUNCTION.notification,
31 | fnParams: [subject, body, fromJid.full],
32 | type: TYPE.announcement,
33 | });
34 |
35 | return this.PRESERVE_HANDLER;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/images/microphone_disabled_black.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/images/microphone_disabled_white.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/api/v1/debug.ts:
--------------------------------------------------------------------------------
1 | import Client from '@src/Client';
2 | import Log from '@util/Log';
3 |
4 | export function enableDebugMode() {
5 | let storage = Client.getStorage();
6 |
7 | storage.setItem('debug', true);
8 | }
9 |
10 | export function disableDebugMode() {
11 | let storage = Client.getStorage();
12 |
13 | storage.setItem('debug', false);
14 | }
15 |
16 | export function deleteAllData() {
17 | if (!Client.isDebugMode()) {
18 | Log.warn('This action is only available in debug mode.');
19 |
20 | return 0;
21 | }
22 |
23 | let storage = Client.getStorage();
24 | let prefix = storage.getPrefix();
25 | let prefixRegex = new RegExp('^' + prefix);
26 | let backend = storage.getBackend();
27 | let keys = Object.keys(backend);
28 | let count = 0;
29 |
30 | for (let key of keys) {
31 | if (prefixRegex.test(key) && key !== prefix + 'debug') {
32 | backend.removeItem(key);
33 | count++;
34 | }
35 | }
36 |
37 | return count;
38 | }
39 |
40 | export function deleteObsoleteData() {
41 | let storage = Client.getStorage();
42 | let backend = storage.getBackend();
43 | let keys = Object.keys(backend);
44 | let count = 0;
45 |
46 | for (let key of keys) {
47 | if (/^jsxc:/.test(key)) {
48 | backend.removeItem(key);
49 | count++;
50 | }
51 | }
52 |
53 | return count;
54 | }
55 |
--------------------------------------------------------------------------------
/src/plugins/omemo/vendor/Signal.ts:
--------------------------------------------------------------------------------
1 |
2 | export interface ISignalBundleObject {
3 | identityKey: ArrayBuffer,
4 | registrationId: number,
5 | preKey: {
6 | keyId: number
7 | publicKey: ArrayBuffer
8 | },
9 | signedPreKey: {
10 | keyId: number
11 | publicKey: ArrayBuffer
12 | signature: string | ArrayBuffer
13 | }
14 | }
15 |
16 | interface ISignalPreKey {
17 | keyId: number
18 |
19 | keyPair: ISignalKeyPair
20 | }
21 |
22 | interface ISignalSignedPreKey extends ISignalPreKey {
23 | signature: ArrayBuffer
24 | }
25 |
26 | interface ISignalKeyPair {
27 | privKey?: ArrayBuffer
28 |
29 | pubKey: ArrayBuffer
30 | }
31 |
32 | interface ISignalKeyHelper {
33 | generatePreKey: (keyId: number) => Promise
34 |
35 | generateSignedPreKey: (identityKeyPair: ISignalKeyPair, signedKeyId: number) => Promise
36 |
37 | generateIdentityKeyPair: () => Promise
38 |
39 | generateRegistrationId: () => number
40 | }
41 |
42 | let libsignal = ( window).libsignal || {};
43 |
44 | export let SignalAddress = libsignal.SignalProtocolAddress;
45 | export let SignalKeyHelper: ISignalKeyHelper = libsignal.KeyHelper;
46 | export let SignalSessionBuilder = libsignal.SessionBuilder;
47 | export let SignalSessionCipher = libsignal.SessionCipher;
48 | export let SignalFingerprintGenerator = libsignal.FingerprintGenerator;
49 |
--------------------------------------------------------------------------------
/images/pick_up_white_disabled.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/connection/xmpp/handlers/multiUser/DirectInvitation.ts:
--------------------------------------------------------------------------------
1 | import JID from '../../../../JID'
2 | import AbstractHandler from '../../AbstractHandler'
3 | import { TYPE as NOTICETYPE, FUNCTION as NOTICEFUNCTION } from '../../../../Notice'
4 | import Log from '@util/Log';
5 |
6 | export default class extends AbstractHandler {
7 | public processStanza(stanza: Element): boolean {
8 | let from = new JID($(stanza).attr('from'));
9 | let contact = this.account.getContact(from);
10 |
11 | if (!contact) {
12 | Log.warn('Got invitation from stranger. Ignore silently.');
13 | } else if (contact.getType() === 'groupchat') {
14 | Log.warn('I don\'t accept direct invitations from MUC rooms.');
15 | }
16 |
17 | let xElement = $(stanza).find('x[xmlns="jabber:x:conference"]');
18 | let roomJid = new JID(xElement.attr('jid'));
19 | let password = xElement.attr('password');
20 | let reason = xElement.attr('reason') || xElement.text(); //pidgin workaround
21 |
22 | this.account.getNoticeManager().addNotice({
23 | title: 'Invitation',
24 | description: `for ${roomJid.bare}`,
25 | type: NOTICETYPE.invitation,
26 | fnName: NOTICEFUNCTION.multiUserInvitation,
27 | fnParams: ['direct', from.bare, roomJid.bare, reason, password, this.account.getUid()]
28 | });
29 |
30 | return this.PRESERVE_HANDLER;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/images/mute_black.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/images/filetypes/folder-public.svg:
--------------------------------------------------------------------------------
1 |
2 |
5 |
--------------------------------------------------------------------------------
/src/connection/xmpp/handlers/jingle.ts:
--------------------------------------------------------------------------------
1 | import Account from '../../../Account'
2 | import AbstractHandler from '../AbstractHandler'
3 | import { STANZA_JINGLE_KEY } from '../../AbstractConnection'
4 |
5 | const FEATURES = [
6 | 'urn:xmpp:jingle:1',
7 | 'urn:xmpp:jingle:apps:rtp:1',
8 | 'urn:xmpp:jingle:apps:rtp:audio',
9 | 'urn:xmpp:jingle:apps:rtp:video',
10 | 'urn:xmpp:jingle:apps:rtp:rtcb-fb:0',
11 | 'urn:xmpp:jingle:apps:rtp:rtp-hdrext:0',
12 | 'urn:xmpp:jingle:apps:rtp:ssma:0',
13 | 'urn:xmpp:jingle:apps:dtls:0',
14 | 'urn:xmpp:jingle:apps:grouping:0',
15 | 'urn:xmpp:jingle:apps:file-transfer:3',
16 | 'urn:xmpp:jingle:transports:ice-udp:1',
17 | 'urn:xmpp:jingle:transports.dtls-sctp:1',
18 | 'urn:ietf:rfc:3264',
19 | 'urn:ietf:rfc:5576',
20 | 'urn:ietf:rfc:5888'
21 | ];
22 |
23 | export default class extends AbstractHandler {
24 | constructor(account: Account) {
25 | super(account);
26 |
27 | for (let feature of FEATURES) {
28 | account.getDiscoInfo().addFeature(feature);
29 | }
30 | }
31 |
32 | public processStanza(stanza: Element) {
33 | let connection = this.account.getConnection();
34 | let storage = this.account.getSessionStorage();
35 |
36 | storage.setItem(STANZA_JINGLE_KEY, stanza.outerHTML);
37 | storage.removeItem(STANZA_JINGLE_KEY);
38 |
39 | connection.getJingleHandler().onJingle(stanza);
40 |
41 | return this.PRESERVE_HANDLER;
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/template/roster.hbs:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
8 | {{#> menu
9 | classes="jsxc-menu--pushup jsxc-grow jsxc-js-presence-menu"
10 | button-label=(t "Offline")}}
11 | {{t "Online"}}
12 | {{t "Chatty"}}
13 | {{t "Away"}}
14 | {{t "Extended_away"}}
15 | {{t "dnd"}}
16 | {{t "Offline"}}
17 | {{/menu}}
18 |
19 | {{> menu classes="jsxc-menu--pushup jsxc-js-notice-menu" button-classes="jsxc-bounce"}}
20 |
21 | {{> menu classes="jsxc-menu--pushup jsxc-js-main-menu" button-classes="jsxc-icon jsxc-icon--menu-dark jsxc-icon--clickable"}}
22 |
23 |
24 | ');
32 | textElement.addClass('jsxc-list__text');
33 | textElement.appendTo(this.element);
34 |
35 | $(' ').text(this.primaryText).addClass('jsxc-list__text__primary').appendTo(textElement);
36 |
37 | if (this.secondaryText) {
38 | $(' ').text(this.secondaryText).addClass('jsxc-list__text__secondary').appendTo(textElement);
39 | }
40 |
41 | if (this.secondaryAction) {
42 | this.secondaryAction.addClass('jsxc-list__secondary-action');
43 | this.element.append(this.secondaryAction);
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/template/loginBox.hbs:
--------------------------------------------------------------------------------
1 | {{t "Login"}}
2 |
3 |
32 |
--------------------------------------------------------------------------------
/images/padlock_open_disabled_black.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/template/contact.hbs:
--------------------------------------------------------------------------------
1 | {{t "Add_buddy"}}
2 |
3 | {{t "Type_in_the_full_username_"}}
4 |
5 |
38 |
--------------------------------------------------------------------------------
/src/plugins/bookmarks/BookmarksPlugin.ts:
--------------------------------------------------------------------------------
1 | import { AbstractPlugin, IMetaData } from '../../plugin/AbstractPlugin'
2 | import PluginAPI from '../../plugin/PluginAPI'
3 | import { PubSubService } from './services/PubSubService';
4 | import LocalService from './services/LocalService';
5 | import BookmarkProvider from './BookmarkProvider';
6 | import Translation from '@util/Translation';
7 |
8 | const MIN_VERSION = '4.0.0';
9 | const MAX_VERSION = '99.0.0';
10 |
11 | export default class BookmarksPlugin extends AbstractPlugin {
12 | public static getId(): string {
13 | return 'bookmarks';
14 | }
15 |
16 | public static getName(): string {
17 | return 'Bookmarks';
18 | }
19 |
20 | public static getMetaData(): IMetaData {
21 | return {
22 | description: Translation.t('setting-bookmarks-enable'),
23 | xeps: [{
24 | id: 'XEP-0048',
25 | name: 'Bookmarks',
26 | version: '1.1',
27 | }]
28 | }
29 | }
30 |
31 | constructor(pluginAPI: PluginAPI) {
32 | super(MIN_VERSION, MAX_VERSION, pluginAPI);
33 |
34 | let contactManager = pluginAPI.getContactManager();
35 | let provider = new BookmarkProvider(contactManager, pluginAPI.createMultiUserContact.bind(pluginAPI));
36 |
37 | provider.registerService(new LocalService(pluginAPI.getStorage()));
38 |
39 | //@TODO test if pubsub is available
40 | let pubSub = new PubSubService(pluginAPI.getConnection());
41 | provider.registerService(pubSub);
42 |
43 | pluginAPI.registerContactProvider(provider);
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/FallbackContactProvider.ts:
--------------------------------------------------------------------------------
1 | import ContactProvider from './ContactProvider';
2 | import { IContact } from './Contact.interface';
3 | import { IJID } from './JID.interface';
4 | import Contact from './Contact';
5 | import Account from './Account';
6 | import MultiUserContact from './MultiUserContact';
7 | import ContactManager from './ContactManager';
8 |
9 | export const FALLBACK_ID = 'fallback';
10 |
11 | export default class FallbackContactProvider extends ContactProvider {
12 | constructor(protected contactManager: ContactManager, private account: Account) {
13 | super(contactManager);
14 | }
15 |
16 | public getUid(): string {
17 | return FALLBACK_ID;
18 | }
19 |
20 | public load(): Promise {
21 | return Promise.resolve([]);
22 | }
23 |
24 | public add(contact: IContact): Promise {
25 | return Promise.resolve(false);
26 | }
27 |
28 | public createContact(jid: IJID, name?: string): IContact
29 | public createContact(id: string): IContact
30 | public createContact() {
31 | if (typeof arguments[0] === 'string') {
32 | let contact = new Contact(this.account, arguments[0]);
33 |
34 | if (contact.isGroupChat()) {
35 | return new MultiUserContact(this.account, arguments[0]);
36 | } else {
37 | return contact;
38 | }
39 | }
40 |
41 | let contact = new Contact(this.account, arguments[0], arguments[1]);
42 | contact.setProvider(this);
43 |
44 | return contact;
45 | }
46 |
47 | public deleteContact(jid: IJID): Promise {
48 | return Promise.resolve();
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/scss/partials/_button.scss:
--------------------------------------------------------------------------------
1 | .jsxc-button {
2 | background-image: none;
3 | // border: 1px solid transparent;
4 | // border-radius: 4px;
5 | border: 0;
6 | cursor: pointer;
7 | display: inline-block;
8 | font-size: 14px;
9 | font-weight: 400;
10 | line-height: 1.42857143;
11 | margin: 0 2px;
12 | min-width: 25px;
13 | padding: 6px 12px;
14 | padding: 10px 16px;
15 | text-align: center;
16 | text-decoration: none;
17 | transition: background-color 0.5s;
18 | user-select: none;
19 | vertical-align: middle;
20 | white-space: nowrap;
21 | width: auto;
22 |
23 | &--block {
24 | display: block;
25 | width: 100%;
26 | }
27 |
28 | &--default {
29 | background-color: rgba(240, 240, 240, 0.9);
30 | border-color: #ccc;
31 | color: #555;
32 |
33 | &:hover {
34 | background-color: #d6d6d6;
35 | }
36 | }
37 |
38 | &--primary {
39 | background-color: #337ab7;
40 | border-color: #2e6da4;
41 | color: #fff;
42 |
43 | &:hover {
44 | background-color: #296496;
45 | }
46 | }
47 |
48 | &--secondary {
49 | background-color: #7daad2;
50 | border-color: #658caf;
51 | color: #fff;
52 |
53 | &:hover {
54 | background-color: #6b99c1;
55 | }
56 | }
57 |
58 | &--success {
59 | background-color: #6bad50;
60 | border-color: #487735;
61 | color: #fff;
62 |
63 | &:hover {
64 | background-color: #5a9443;
65 | }
66 | }
67 |
68 | &[disabled],
69 | &[disabled]:hover {
70 | background-color: #337ab7;
71 | border-color: #2e6da4;
72 | color: #fff;
73 | cursor: not-allowed;
74 | opacity: 0.65;
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/src/ui/ChatWindowFileTransferHandler.ts:
--------------------------------------------------------------------------------
1 | import ChatWindow from '../ui/ChatWindow'
2 | import Attachment from '../Attachment'
3 |
4 | export default class FileTransferHandler {
5 | private handlerElement;
6 |
7 | constructor(private chatWindow: ChatWindow) {
8 | this.handlerElement = this.chatWindow.getDom().find('.jsxc-file-transfer');
9 |
10 | this.handlerElement.on('click', this.showFileSelection);
11 |
12 | this.chatWindow.getDom().find('.jsxc-window').on('drop', (ev) => {
13 | ev.preventDefault();
14 |
15 | let files = ( ev.originalEvent).dataTransfer.files;
16 |
17 | if (files && files.length) {
18 | this.fileSelected(files[0]);
19 | }
20 | });
21 | }
22 |
23 | private showFileSelection = (ev) => {
24 | if (ev.target !== this.handlerElement.get(0)) {
25 | // prevent bubbled event
26 | return;
27 | }
28 |
29 | this.showFileSelectionDialog();
30 | }
31 |
32 | private showFileSelectionDialog() {
33 | let labelElement = this.handlerElement.find('label');
34 | let fileElement = this.handlerElement.find('input');
35 |
36 | // open file selection for user
37 | labelElement.click();
38 |
39 | fileElement.off('change').change((ev) => {
40 | let file: File = ev.target.files[0]; // FileList object
41 |
42 | if (!file) {
43 | return;
44 | }
45 |
46 | this.fileSelected(file);
47 | });
48 | }
49 |
50 | private fileSelected(file: File) {
51 | let attachment = new Attachment(file);
52 | this.chatWindow.setAttachment(attachment);
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/images/presence/online.svg:
--------------------------------------------------------------------------------
1 |
2 |
52 |
--------------------------------------------------------------------------------
/template/bookmark.hbs:
--------------------------------------------------------------------------------
1 |
2 |
40 |
--------------------------------------------------------------------------------
/src/connection/services/PEP.ts:
--------------------------------------------------------------------------------
1 | import AbstractService from './AbstractService'
2 | import { $iq } from '../../vendor/Strophe'
3 |
4 | export default class PEP extends AbstractService {
5 |
6 | public subscribe(node: string, handler: (stanza: string) => boolean, force: boolean = false) {
7 | this.account.getDiscoInfo().addFeature(node);
8 | this.account.getDiscoInfo().addFeature(`${node}+notify`);
9 |
10 | this.connection.registerHandler(handler, 'http://jabber.org/protocol/pubsub#event', 'message', null, null, null);
11 |
12 | if (force) {
13 | return this.connection.sendPresence();
14 | }
15 | }
16 |
17 | public unsubscribe(node: string, force: boolean = false) {
18 | this.account.getDiscoInfo().removeFeature(node)
19 | this.account.getDiscoInfo().removeFeature(`${node}+notify`)
20 |
21 | if (force) {
22 | return this.connection.sendPresence();
23 | }
24 | }
25 |
26 | public publish(node: string, element: Element, id?: string): Promise {
27 | let iqStanza = $iq({
28 | type: 'set',
29 | }).c('pubsub', {
30 | xmlns: 'http://jabber.org/protocol/pubsub'
31 | }).c('publish', {
32 | node
33 | }).c('item', {
34 | id
35 | }).cnode(element);
36 |
37 | return this.sendIQ(iqStanza);
38 | }
39 |
40 | public retrieveItems(node: string, jid?: string) {
41 | let iq = $iq({
42 | to: jid,
43 | type: 'get'
44 | });
45 |
46 | iq.c('pubsub', {
47 | xmlns: 'http://jabber.org/protocol/pubsub'
48 | });
49 | iq.c('items', {
50 | node
51 | });
52 |
53 | return this.sendIQ(iq);
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/images/filetypes/application.svg:
--------------------------------------------------------------------------------
1 |
2 |
7 |
--------------------------------------------------------------------------------
/scss/modules/_animation.scss:
--------------------------------------------------------------------------------
1 | @keyframes jsxc-bounce-6 {
2 | 0% {
3 | transform: scale(1, 1) translateY(0);
4 | }
5 |
6 | 10% {
7 | transform: scale(1.1, 0.9) translateY(0);
8 | }
9 |
10 | 30% {
11 | transform: scale(0.9, 1.1) translateY(-10px);
12 | }
13 |
14 | 50% {
15 | transform: scale(1.05, 0.95) translateY(0);
16 | }
17 |
18 | 57% {
19 | transform: scale(1, 1) translateY(-1px);
20 | }
21 |
22 | 64% {
23 | transform: scale(1, 1) translateY(0);
24 | }
25 |
26 | 100% {
27 | transform: scale(1, 1) translateY(0);
28 | }
29 | }
30 |
31 | @keyframes jsxc-establishing {
32 | 0% {
33 | background-color: $establishing-color1;
34 | border-width: 0;
35 | margin-left: -20px;
36 | width: 40px;
37 | }
38 |
39 | 50% {
40 | background-color: $establishing-color2;
41 | margin-left: -40px;
42 | width: 80px;
43 | }
44 |
45 | 100% {
46 | background-color: $establishing-color1;
47 | border-width: 0;
48 | margin-left: -20px;
49 | width: 40px;
50 | }
51 | }
52 |
53 | @keyframes jsxc-ringing {
54 | 0% {
55 | background-color: $ringing-color1;
56 | height: 20px;
57 | margin-left: -10px;
58 | margin-top: -10px;
59 | width: 20px;
60 | }
61 |
62 | 50% {
63 | background-color: $ringing-color2;
64 | height: 80px;
65 | margin-left: -40px;
66 | margin-top: -40px;
67 | width: 80px;
68 | }
69 |
70 | 100% {
71 | background-color: $ringing-color1;
72 | height: 20px;
73 | margin-left: -10px;
74 | margin-top: -10px;
75 | width: 20px;
76 | }
77 | }
78 |
79 | @keyframes jsxc-rotate {
80 | 0% {
81 | transform: rotate(0deg);
82 | }
83 |
84 | 100% {
85 | transform: rotate(360deg);
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/src/DiscoInfoChangeable.ts:
--------------------------------------------------------------------------------
1 | import DiscoInfo from './DiscoInfo'
2 | import DiscoInfoVersion from './DiscoInfoVersion';
3 |
4 | export default class DiscoInfoChangeable extends DiscoInfo {
5 |
6 | constructor(id: string) {
7 | super(id);
8 | }
9 |
10 | public getCapsVersion(): String {
11 | return DiscoInfoVersion.generate(this.getIdentities(), this.getFeatures(), []);
12 | }
13 |
14 | public addIdentity(category: string, type: string, name: string = '', lang: string = ''): boolean {
15 | let identities = this.getIdentities();
16 |
17 | for (let identity of identities) {
18 | if (identity.category === category &&
19 | identity.type === type &&
20 | identity.name === name &&
21 | identity.lang === lang) {
22 | return false;
23 | }
24 | }
25 |
26 | identities.push({
27 | category,
28 | type,
29 | name,
30 | lang
31 | });
32 | this.data.set('identities', identities);
33 |
34 | return true;
35 | }
36 |
37 | public addFeature(feature: string): boolean {
38 | let features = this.getFeatures();
39 |
40 | if (features.indexOf(feature) > -1) {
41 | return false;
42 | }
43 |
44 | features.push(feature);
45 | this.data.set('features', features);
46 |
47 | return true;
48 | }
49 |
50 | public removeFeature(feature: string): boolean {
51 | let features = this.getFeatures();
52 | let index = features.indexOf(feature);
53 |
54 | if (index > -1) {
55 | features.splice(index, 1);
56 | this.data.set('features', features);
57 |
58 | return true;
59 | }
60 |
61 | return false;
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/images/XMPP_logo.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/example/js/example.js:
--------------------------------------------------------------------------------
1 | let jsxc = new JSXC({
2 | loadConnectionOptions: (username, password) => {
3 | return Promise.resolve({
4 | xmpp: {
5 | url: $('#bosh-url').val(),
6 | domain: $('#xmpp-domain').val(),
7 | }
8 | });
9 | },
10 | connectionCallback: (jid, status) => {
11 | const CONNECTED = 5;
12 | const ATTACHED = 8;
13 |
14 | if (status === CONNECTED || status === ATTACHED) {
15 | $('.logout').show();
16 | $('.submit').hide();
17 | } else {
18 | $('.logout').hide();
19 | $('.submit').show();
20 | }
21 | }
22 | });
23 |
24 | subscribeToInstantLogin();
25 | watchForm();
26 | watchLogoutButton();
27 |
28 | function watchForm() {
29 | let formElement = $('#watch-form');
30 | let usernameElement = $('#watch-username');
31 | let passwordElement = $('#watch-password');
32 |
33 | jsxc.watchForm(formElement, usernameElement, passwordElement);
34 | }
35 |
36 | function watchLogoutButton() {
37 | let buttonElements = $('.logout');
38 |
39 | jsxc.watchLogoutClick(buttonElements);
40 | }
41 |
42 | function subscribeToInstantLogin() {
43 | $('#instant-login-form').submit(function(ev) {
44 | var url = $('#bosh-url').val();
45 | var domain = $('#xmpp-domain').val();
46 |
47 | var username = $(this).find('[name="username"]').val();
48 | var password = $(this).find('[name="password"]').val();
49 |
50 | var jid = username + '@' + domain;
51 |
52 | jsxc.start(url, jid, password)
53 | .then(function() {
54 | console.log('>>> CONNECTION READY')
55 | }).catch(function(err) {
56 | console.log('>>> catch', err)
57 | })
58 |
59 | return false;
60 | });
61 | }
62 |
--------------------------------------------------------------------------------
/src/util/Translation.ts:
--------------------------------------------------------------------------------
1 | import i18next from 'i18next'
2 | import Log from '@util/Log';
3 | import Client from '@src/Client';
4 | import LanguageDetector from 'i18next-browser-languagedetector'
5 |
6 | let resources = __LANGS__.reduce((resources, lang) => {
7 | resources[lang] = require(`../../locales/${lang}.json`);
8 |
9 | return resources;
10 | }, {});
11 |
12 | export default class Translation {
13 | private static initialized = false;
14 |
15 | public static initialize() {
16 | if (Client.getOption('autoLang')) {
17 | i18next.use(LanguageDetector);
18 | }
19 |
20 | i18next.init({
21 | debug: Client.isDebugMode(),
22 | lng: Client.getOption('lang'),
23 | fallbackLng: 'en',
24 | returnNull: false,
25 | resources,
26 | interpolation: {
27 | prefix: '__',
28 | suffix: '__'
29 | },
30 | saveMissing: true,
31 | detection: {
32 | order: ['querystring', 'navigator', 'htmlTag', 'path', 'subdomain'],
33 | },
34 | });
35 |
36 | i18next.on('missingKey', function(language, namespace, key, res) {
37 | Log.info(`[i18n] Translation of "${key}" is missing for language "${language}". Namespace: ${namespace}. Resource: ${res}.`);
38 | });
39 |
40 | Translation.initialized = true;
41 | }
42 |
43 | public static t(text: string, param?): string {
44 | if (!Translation.initialized) {
45 | Log.warn('Translator not initialized');
46 |
47 | return text;
48 | }
49 |
50 | let translatedString = i18next.t(text, param);
51 |
52 | return translatedString;
53 | }
54 |
55 | public static getCurrentLanguage() {
56 | return i18next.language;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/Avatar.ts:
--------------------------------------------------------------------------------
1 | import { IAvatar } from './Avatar.interface'
2 | import Client from './Client'
3 | import PersistentMap from './util/PersistentMap'
4 | import * as sha1 from 'js-sha1'
5 |
6 | export default class implements IAvatar {
7 | private properties: PersistentMap;
8 |
9 | constructor(private sha1Hash: string, type?: string, data?: string) {
10 | let storage = Client.getStorage();
11 | this.properties = new PersistentMap(storage, sha1Hash);
12 |
13 | if (!this.properties.get('data')) {
14 | if (data && type) {
15 | let expectedHash = this.calculateHash(data);
16 |
17 | if (expectedHash !== sha1Hash) {
18 | throw new Error('SHA-1 hash doesnt match');
19 | }
20 |
21 | this.properties.set('data', data);
22 | this.properties.set('type', type);
23 | } else {
24 | throw new Error('Avatar not found');
25 | }
26 | }
27 | }
28 |
29 | public getData(): string {
30 | return this.properties.get('data');
31 | }
32 |
33 | public getType(): string {
34 | return this.properties.get('type');
35 | }
36 |
37 | public getHash(): string {
38 | return this.sha1Hash;
39 | }
40 |
41 | private calculateHash(data: string): string {
42 | let base64 = data.replace(/^.+;base64,/, '');
43 | let buffer = this.base64ToArrayBuffer(base64);
44 |
45 | return sha1(buffer);
46 | }
47 |
48 | private base64ToArrayBuffer(base64String) {
49 | let binaryString = window.atob(base64String);
50 | let bytes = new Uint8Array(binaryString.length);
51 |
52 | for (let i = 0; i < binaryString.length; i++) {
53 | bytes[i] = binaryString.charCodeAt(i);
54 | }
55 |
56 | return bytes.buffer;
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/JingleStreamSession.ts:
--------------------------------------------------------------------------------
1 | import JingleHandler from '@connection/JingleHandler';
2 | import Log from '@util/Log';
3 | import JingleMediaSession from './JingleMediaSession';
4 | import Notification from './Notification';
5 | import Translation from '@util/Translation';
6 | import { SOUNDS } from './CONST';
7 |
8 | export default class JingleStreamSession extends JingleMediaSession {
9 |
10 | public onOnceIncoming() {
11 | Notification.notify({
12 | title: Translation.t('Incoming_stream'),
13 | message: Translation.t('from_sender') + this.peerContact.getName(),
14 | source: this.peerContact,
15 | });
16 |
17 | Notification.playSound(SOUNDS.CALL, true, true);
18 |
19 | this.on('terminated', () => {
20 | Notification.stopSound();
21 | });
22 |
23 | this.on('aborted', () => {
24 | Notification.stopSound();
25 | });
26 |
27 | this.on('adopt', () => {
28 | Notification.stopSound();
29 | });
30 |
31 | // send signal to partner
32 | this.session.ring();
33 | }
34 |
35 | protected onIncoming() {
36 | Log.debug('incoming stream from ' + this.session.peerID);
37 |
38 | let videoDialog = JingleHandler.getVideoDialog();
39 |
40 | videoDialog.showCallDialog(this).then(() => {
41 | videoDialog.addSession(this);
42 | videoDialog.showVideoWindow();
43 |
44 | this.session.accept();
45 | }).catch((reason) => {
46 |
47 | //@TODO hide user media request overlay
48 |
49 | //@TODO post reason to chat window
50 | if (reason !== 'aborted') {
51 | Log.warn('Decline call', reason)
52 |
53 | this.session.decline();
54 | }
55 | });
56 | }
57 |
58 | public getMediaRequest() {
59 | return [];
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/plugins/MeCommandPlugin.ts:
--------------------------------------------------------------------------------
1 | import { AbstractPlugin, IMetaData } from '../plugin/AbstractPlugin'
2 | import PluginAPI from '../plugin/PluginAPI'
3 | import Contact from '../Contact'
4 | import Translation from '@util/Translation';
5 | import { DIRECTION } from '@src/Message.interface';
6 |
7 | const MIN_VERSION = '4.0.0';
8 | const MAX_VERSION = '99.0.0';
9 |
10 | export default class MeCommandPlugin extends AbstractPlugin {
11 | public static getId(): string {
12 | return 'me-command';
13 | }
14 |
15 | public static getName(): string {
16 | return 'The /me Command';
17 | }
18 |
19 | public static getMetaData(): IMetaData {
20 | return {
21 | description: Translation.t('setting-meCommand-enable'),
22 | xeps: [{
23 | id: 'XEP-0245',
24 | name: 'The /me Command',
25 | version: '1.0',
26 | }]
27 | }
28 | }
29 |
30 | constructor(pluginAPI: PluginAPI) {
31 | super(MIN_VERSION, MAX_VERSION, pluginAPI);
32 |
33 | pluginAPI.registerTextFormatter(this.textFormatter);
34 | }
35 |
36 | private textFormatter = (plaintext: string, direction: DIRECTION, contact: Contact, senderName: string) => {
37 | let meRegex = /^\/me /;
38 |
39 | if (direction !== DIRECTION.IN) {
40 | return plaintext.replace(meRegex, `/me `);
41 | }
42 |
43 | if (!senderName && !contact) {
44 | return plaintext;
45 | }
46 |
47 | if (meRegex.test(plaintext)) {
48 | let name = senderName || contact.getName();
49 |
50 | if (name.indexOf('@') > -1) {
51 | name = name.slice(0, name.indexOf('@'));
52 | }
53 |
54 | plaintext = plaintext.replace(meRegex, `${name} `);
55 | }
56 |
57 | return plaintext;
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/scripts/search-blacklist.js:
--------------------------------------------------------------------------------
1 | require('colors');
2 | const childProcess = require('child_process');
3 |
4 | function escapeRegex(str) {
5 | return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
6 | }
7 |
8 | const BLACKLIST = ['console.'];
9 | const BLACKLIST_REGEX = new RegExp(BLACKLIST.map(word => escapeRegex(word)).join('|'), 'g');
10 |
11 | function exec(command) {
12 | return new Promise((resolve, reject) => {
13 | childProcess.exec(command, (error, stdout, stderr) => {
14 | if (error) {
15 | reject(error);
16 | } else {
17 | resolve([stdout, stderr]);
18 | }
19 | });
20 | });
21 | }
22 |
23 | async function getDiff() {
24 | let [output] = await exec('git diff --staged');
25 |
26 | return output.split('\n');
27 | }
28 |
29 | async function getAdditions() {
30 | let diff = await getDiff();
31 |
32 | return diff.filter(line => /^\+/.test(line));
33 | }
34 |
35 | getAdditions().then(additions => {
36 | let output = [];
37 | let currentFile;
38 | let currentFileAdded = false;
39 |
40 | for (let addition of additions) {
41 | if (/^\+\+\+/.test(addition)) {
42 | currentFile = addition;
43 | currentFileAdded = false;
44 | } else if (BLACKLIST_REGEX.test(addition)) {
45 | if (!currentFileAdded) {
46 | output.push(currentFile);
47 | currentFileAdded = true;
48 | }
49 |
50 | output.push(addition);
51 | }
52 | }
53 |
54 | if (output.length) {
55 | console.log(`✖ Found some blacklisted terms. Please remove them before you commit our changes.`.red);
56 | console.log(output.join('\n').replace(BLACKLIST_REGEX, (match) => match.yellow));
57 |
58 | process.exit(1);
59 | }
60 | })
61 |
--------------------------------------------------------------------------------
/src/plugins/omemo/vendor/KeyHelper.ts:
--------------------------------------------------------------------------------
1 | import PreKey from '../model/PreKey';
2 | import SignedPreKey from '../model/SignedPreKey';
3 | import IdentityKey from '../model/IdentityKey';
4 | import { SignalKeyHelper } from './Signal';
5 |
6 | export class KeyHelper {
7 | public static async generatePreKey(keyId: number): Promise {
8 | let signalPreKey = await SignalKeyHelper.generatePreKey(keyId);
9 |
10 | return new PreKey({
11 | keyId: signalPreKey.keyId,
12 | keyPair: {
13 | publicKey: signalPreKey.keyPair.pubKey,
14 | privateKey: signalPreKey.keyPair.privKey,
15 | },
16 | });
17 | }
18 |
19 | public static async generateSignedPreKey(identityKey: IdentityKey, signedKeyId: number): Promise {
20 | let signalIdentityKey = {
21 | pubKey: identityKey.getPublic(),
22 | privKey: identityKey.getPrivate(),
23 | };
24 |
25 | let signalSignedPreKey = await SignalKeyHelper.generateSignedPreKey(signalIdentityKey, signedKeyId);
26 |
27 | return new SignedPreKey({
28 | keyId: signalSignedPreKey.keyId,
29 | keyPair: {
30 | publicKey: signalSignedPreKey.keyPair.pubKey,
31 | privateKey: signalSignedPreKey.keyPair.privKey,
32 | },
33 | signature: signalSignedPreKey.signature,
34 | });
35 | }
36 |
37 | public static async generateIdentityKey(): Promise {
38 | let signalIdentityKey = await SignalKeyHelper.generateIdentityKeyPair();
39 |
40 | return new IdentityKey({
41 | publicKey: signalIdentityKey.pubKey,
42 | privateKey: signalIdentityKey.privKey,
43 | });
44 | }
45 |
46 | public static generateRegistrationId(): number {
47 | return SignalKeyHelper.generateRegistrationId();
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/util/Utils.ts:
--------------------------------------------------------------------------------
1 |
2 | export default class Utils {
3 | public static removeHTML(text: string): string {
4 | return $('').html(text).text();
5 | }
6 |
7 | public static escapeHTML(text: string): string {
8 | text = text.replace(/</g, '<').replace(/>/g, '>').replace(/&/g, '&');
9 | return text.replace(/&/g, '&').replace(//g, '>');
10 | }
11 |
12 | public static diffArray(newArray: any[], oldArray: any[]): { newValues: any[], deletedValues: any[] } {
13 | newArray = newArray || [];
14 | oldArray = oldArray || [];
15 |
16 | return {
17 | newValues: newArray.filter(id => (oldArray).indexOf(id) < 0),
18 | deletedValues: oldArray.filter(id => newArray.indexOf(id) < 0),
19 | }
20 | }
21 |
22 | public static isObject(candidate: any) {
23 | return !!candidate && candidate.constructor === Object;
24 | }
25 |
26 | public static mergeDeep(target: Object, ...sources: Object[]): Object {
27 | if (!sources.length) {
28 | return target;
29 | }
30 | if (!Utils.isObject(target)) {
31 | throw new Error('Target has to be an object');
32 | }
33 | const source = sources.shift();
34 |
35 | if (Utils.isObject(source)) {
36 | for (const key in source) {
37 | if (Utils.isObject(source[key])) {
38 | if (!target[key]) {
39 | Object.assign(target, { [key]: {} });
40 | }
41 |
42 | Utils.mergeDeep(target[key], source[key]);
43 | } else {
44 | Object.assign(target, { [key]: source[key] });
45 | }
46 | }
47 | }
48 |
49 | return Utils.mergeDeep(target, ...sources);
50 | }
51 |
52 | public static prettifyHex(hex: string) {
53 | return hex.replace(/(.{8})/g, '$1 ').replace(/ $/, '');
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/example/login.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | JSXC example application
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 | This page simulates your protected area or your login target.
24 |
25 |
26 | You are not logged in! Maybe your password was wrong. Back
27 |
28 |
29 |
30 | The following link has the id which was passed to jsxc as logoutElement:
31 |
32 | Log out and redirect to index.html
33 |
34 | |