+
+);
diff --git a/ts/components/session/RegistrationTabs.tsx b/ts/components/session/RegistrationTabs.tsx
new file mode 100644
index 000000000..610c506e4
--- /dev/null
+++ b/ts/components/session/RegistrationTabs.tsx
@@ -0,0 +1,763 @@
+import React from 'react';
+import classNames from 'classnames';
+
+import { SessionInput } from './SessionInput';
+import {
+ SessionButton,
+ SessionButtonColor,
+ SessionButtonType,
+} from './SessionButton';
+import { trigger } from '../../shims/events';
+import { SessionHtmlRenderer } from './SessionHTMLRenderer';
+
+enum SignInMode {
+ Default,
+ UsingSeed,
+ LinkingDevice,
+}
+
+enum SignUpMode {
+ Default,
+ SessionIDShown,
+ EnterDetails,
+}
+
+enum TabType {
+ Create,
+ SignIn,
+}
+
+interface State {
+ selectedTab: TabType;
+ signInMode: SignInMode;
+ signUpMode: SignUpMode;
+ displayName: string;
+ password: string;
+ validatePassword: string;
+ passwordErrorString: string;
+ passwordFieldsMatch: boolean;
+ mnemonicSeed: string;
+ hexGeneratedPubKey: string;
+ primaryDevicePubKey: string;
+}
+
+const Tab = ({
+ isSelected,
+ label,
+ onSelect,
+ type,
+}: {
+ isSelected: boolean;
+ label: string;
+ onSelect?: (event: TabType) => void;
+ type: TabType;
+}) => {
+ const handleClick = onSelect
+ ? () => {
+ onSelect(type);
+ }
+ : undefined;
+
+ return (
+
+
+
+ {label}
+
+ );
+};
+
+export class RegistrationTabs extends React.Component<{}, State> {
+ private readonly accountManager: any;
+
+ constructor(props: any) {
+ super(props);
+
+ this.onSeedChanged = this.onSeedChanged.bind(this);
+ this.onDisplayNameChanged = this.onDisplayNameChanged.bind(this);
+ this.onPasswordChanged = this.onPasswordChanged.bind(this);
+ this.onPasswordVerifyChanged = this.onPasswordVerifyChanged.bind(this);
+ this.onSignUpGenerateSessionIDClick = this.onSignUpGenerateSessionIDClick.bind(
+ this
+ );
+ this.onSignUpGetStartedClick = this.onSignUpGetStartedClick.bind(this);
+ this.onSecondDeviceSessionIDChanged = this.onSecondDeviceSessionIDChanged.bind(
+ this
+ );
+ this.onSecondaryDeviceRegistered = this.onSecondaryDeviceRegistered.bind(
+ this
+ );
+ this.onCompleteSignUpClick = this.onCompleteSignUpClick.bind(this);
+ this.handlePressEnter = this.handlePressEnter.bind(this);
+ this.handleContinueYourSessionClick = this.handleContinueYourSessionClick.bind(
+ this
+ );
+
+ this.state = {
+ selectedTab: TabType.Create,
+ signInMode: SignInMode.Default,
+ signUpMode: SignUpMode.Default,
+ displayName: '',
+ password: '',
+ validatePassword: '',
+ passwordErrorString: '',
+ passwordFieldsMatch: false,
+ mnemonicSeed: '',
+ hexGeneratedPubKey: '',
+ primaryDevicePubKey: '',
+ };
+
+ this.accountManager = window.getAccountManager();
+ // Clean status in case the app closed unexpectedly
+ window.textsecure.storage.remove('secondaryDeviceStatus');
+ }
+
+ public render() {
+ this.generateMnemonicAndKeyPair().ignore();
+
+ return this.renderTabs();
+ }
+
+ private async generateMnemonicAndKeyPair() {
+ if (this.state.mnemonicSeed === '') {
+ const language = 'english';
+ const mnemonic = await this.accountManager.generateMnemonic(language);
+
+ let seedHex = window.mnemonic.mn_decode(mnemonic, language);
+ // handle shorter than 32 bytes seeds
+ const privKeyHexLength = 32 * 2;
+ if (seedHex.length !== privKeyHexLength) {
+ seedHex = seedHex.concat(seedHex);
+ seedHex = seedHex.substring(0, privKeyHexLength);
+ }
+ const privKeyHex = window.mnemonic.sc_reduce32(seedHex);
+ const privKey = window.dcodeIO.ByteBuffer.wrap(
+ privKeyHex,
+ 'hex'
+ ).toArrayBuffer();
+ const keyPair = await window.libsignal.Curve.async.createKeyPair(privKey);
+ const hexGeneratedPubKey = Buffer.from(keyPair.pubKey).toString('hex');
+
+ this.setState({
+ mnemonicSeed: mnemonic,
+ hexGeneratedPubKey, // our 'frontend' sessionID
+ });
+ }
+ }
+
+ private renderTabs() {
+ const { selectedTab } = this.state;
+
+ const createAccount = window.i18n('createAccount');
+ const signIn = window.i18n('signIn');
+ const isCreateSelected = selectedTab === TabType.Create;
+ const isSignInSelected = selectedTab === TabType.SignIn;
+
+ return (
+
+
+ );
+ }
+
+ private readonly handleTabSelect = (tabType: TabType): void => {
+ if (tabType !== TabType.SignIn) {
+ this.cancelSecondaryDevice().ignore();
+ }
+ this.setState({
+ selectedTab: tabType,
+ signInMode: SignInMode.Default,
+ signUpMode: SignUpMode.Default,
+ displayName: '',
+ password: '',
+ validatePassword: '',
+ passwordErrorString: '',
+ passwordFieldsMatch: false,
+ mnemonicSeed: '',
+ hexGeneratedPubKey: '',
+ primaryDevicePubKey: '',
+ });
+ };
+
+ private onSeedChanged(val: string) {
+ this.setState({ mnemonicSeed: val });
+ }
+
+ private onDisplayNameChanged(val: string) {
+ const sanitizedName = this.sanitiseNameInput(val);
+ this.setState({ displayName: sanitizedName });
+ }
+
+ private onPasswordChanged(val: string) {
+ this.setState({ password: val });
+ this.onValidatePassword(); // FIXME add bubbles or something to help the user know what he did wrong
+ }
+
+ private onPasswordVerifyChanged(val: string) {
+ this.setState({ validatePassword: val });
+ }
+
+ private renderSections() {
+ const { selectedTab } = this.state;
+ if (selectedTab === TabType.Create) {
+ return this.renderSignUp();
+ }
+
+ return this.renderSignIn();
+ }
+
+ private renderSignUp() {
+ const { signUpMode } = this.state;
+ switch (signUpMode) {
+ case SignUpMode.Default:
+ return (
+
+
+ {this.renderSections()}
+
+ {this.renderSignUpHeader()}
+ {this.renderSignUpButton()}
+
+ );
+ case SignUpMode.SessionIDShown:
+ return (
+
+ {this.renderSignUpHeader()}
+
+ );
+
+ default:
+ return (
+
+ {window.i18n('yourUniqueSessionID')}
+
+ {this.renderEnterSessionID(false)}
+ {this.renderSignUpButton()}
+ {this.getRenderTermsConditionAgreement()}
+
+ {
+ this.onCompleteSignUpClick();
+ }}
+ buttonType={SessionButtonType.Brand}
+ buttonColor={SessionButtonColor.Green}
+ text={window.i18n('completeSignUp')}
+ />
+
+ );
+ }
+ }
+
+ private getRenderTermsConditionAgreement() {
+ const { selectedTab, signInMode, signUpMode } = this.state;
+ if (selectedTab === TabType.Create) {
+ return signUpMode !== SignUpMode.Default
+ ? this.renderTermsConditionAgreement()
+ : null;
+ } else {
+ return signInMode !== SignInMode.Default
+ ? this.renderTermsConditionAgreement()
+ : null;
+ }
+ }
+
+ private renderSignUpHeader() {
+ const allUsersAreRandomly = window.i18n('allUsersAreRandomly...');
+
+ return
+ {window.i18n('welcomeToYourSession')}
+
+
+ {this.renderRegistrationContent()}
+ {allUsersAreRandomly}
;
+ }
+
+ private renderSignUpButton() {
+ const { signUpMode } = this.state;
+
+ let buttonType: SessionButtonType;
+ let buttonColor: SessionButtonColor;
+ let buttonText: string;
+ if (signUpMode !== SignUpMode.Default) {
+ buttonType = SessionButtonType.Brand;
+ buttonColor = SessionButtonColor.Green;
+ buttonText = window.i18n('getStarted');
+ } else {
+ buttonType = SessionButtonType.BrandOutline;
+ buttonColor = SessionButtonColor.Green;
+ buttonText = window.i18n('generateSessionID');
+ }
+
+ return (
+
+ {this.renderRegistrationContent()}
+
+ {this.renderSignInButtons()}
+ {this.getRenderTermsConditionAgreement()}
+
+ );
+ }
+
+ private renderRegistrationContent() {
+ const { signInMode, signUpMode } = this.state;
+
+ if (signInMode === SignInMode.UsingSeed) {
+ return (
+
+ {
+ this.onSeedChanged(val);
+ }}
+ onEnterPressed={() => {
+ this.handlePressEnter();
+ }}
+ />
+ {this.renderNamePasswordAndVerifyPasswordFields()}
+
+ );
+ }
+ if (signInMode === SignInMode.LinkingDevice) {
+ return (
+
+
+ );
+ }
+ if (signUpMode === SignUpMode.EnterDetails) {
+ return (
+
+ {window.i18n('devicePairingHeader')}
+
+ {this.renderEnterSessionID(true)}
+
+ {this.renderNamePasswordAndVerifyPasswordFields()};
+
+ );
+ }
+
+ return null;
+ }
+
+ private renderNamePasswordAndVerifyPasswordFields() {
+ return (
+
+ {
+ this.onDisplayNameChanged(val);
+ }}
+ onEnterPressed={() => {
+ this.handlePressEnter();
+ }}
+ />
+
+ {
+ this.onPasswordChanged(val);
+ }}
+ onEnterPressed={() => {
+ this.handlePressEnter();
+ }}
+ />
+
+ {
+ this.onPasswordVerifyChanged(val);
+ }}
+ onEnterPressed={() => {
+ this.handlePressEnter();
+ }}
+ />
+
+ );
+ }
+
+ private renderEnterSessionID(contentEditable: boolean) {
+ const enterSessionIDHere = window.i18n('enterSessionIDHere');
+
+ return (
+ {
+ if (contentEditable) {
+ this.onSecondDeviceSessionIDChanged(e);
+ }
+ }}
+ />
+ );
+ }
+
+ private onSecondDeviceSessionIDChanged(e: any) {
+ e.preventDefault();
+ const hexEncodedPubKey = e.target.innerHTML;
+ this.setState({
+ primaryDevicePubKey: hexEncodedPubKey,
+ });
+ }
+
+ private renderSignInButtons() {
+ const { signInMode } = this.state;
+
+ const or = window.i18n('or');
+
+ if (signInMode === SignInMode.Default) {
+ return (
+ {
+ this.handleContinueYourSessionClick();
+ }}
+ buttonType={SessionButtonType.Brand}
+ buttonColor={SessionButtonColor.Green}
+ text={window.i18n('continueYourSession')}
+ />
+ );
+ }
+
+ private renderRestoreUsingSeedButton(
+ buttonType: SessionButtonType,
+ buttonColor: SessionButtonColor
+ ) {
+ return (
+ {
+ this.cancelSecondaryDevice().ignore();
+ this.setState({
+ signInMode: SignInMode.UsingSeed,
+ primaryDevicePubKey: '',
+ mnemonicSeed: '',
+ displayName: '',
+ signUpMode: SignUpMode.Default,
+ });
+ //FIXME ugly hack to empty the content editable div used on enter session ID
+ window.Session.emptyContentEditableDivs();
+ }}
+ buttonType={buttonType}
+ buttonColor={buttonColor}
+ text={window.i18n('restoreUsingSeed')}
+ />
+ );
+ }
+
+ private renderLinkDeviceToExistingAccountButton() {
+ return (
+ {
+ this.setState({
+ signInMode: SignInMode.LinkingDevice,
+ mnemonicSeed: '',
+ displayName: '',
+ signUpMode: SignUpMode.Default,
+ });
+ }}
+ buttonType={SessionButtonType.BrandOutline}
+ buttonColor={SessionButtonColor.White}
+ text={window.i18n('linkDeviceToExistingAccount')}
+ />
+ );
+ }
+
+ private handlePressEnter() {
+ const { signInMode, signUpMode } = this.state;
+ if (signUpMode === SignUpMode.EnterDetails) {
+ this.onCompleteSignUpClick();
+
+ return;
+ }
+
+ if (signInMode === SignInMode.UsingSeed) {
+ this.handleContinueYourSessionClick();
+
+ return;
+ }
+ }
+
+ private trim(value: string) {
+ return value ? value.trim() : value;
+ }
+
+ private validatePassword() {
+ const input = this.trim(this.state.password);
+ const confirmationInput = this.trim(this.state.validatePassword);
+
+ // If user hasn't set a value then skip
+ if (!input && !confirmationInput) {
+ return null;
+ }
+
+ const error = window.passwordUtil.validatePassword(input, window.i18n);
+ if (error) {
+ return error;
+ }
+
+ if (input !== confirmationInput) {
+ return "Password don't match";
+ }
+
+ return null;
+ }
+
+ private onValidatePassword() {
+ const passwordValidation = this.validatePassword();
+ if (passwordValidation) {
+ this.setState({ passwordErrorString: passwordValidation });
+ } else {
+ // Show green box around inputs that match
+ const input = this.trim(this.state.password);
+ const confirmationInput = this.trim(this.state.validatePassword);
+ const passwordFieldsMatch =
+ input !== undefined && input === confirmationInput;
+
+ this.setState({
+ passwordErrorString: '',
+ passwordFieldsMatch,
+ });
+ }
+ }
+
+ private sanitiseNameInput(val: string) {
+ return val.trim().replace(window.displayNameRegex, '');
+ }
+
+ private async resetRegistration() {
+ await window.Signal.Data.removeAllIdentityKeys();
+ await window.Signal.Data.removeAllPrivateConversations();
+ window.Whisper.Registration.remove();
+ // Do not remove all items since they are only set
+ // at startup.
+ window.textsecure.storage.remove('identityKey');
+ window.textsecure.storage.remove('secondaryDeviceStatus');
+ window.ConversationController.reset();
+ await window.ConversationController.load();
+ window.Whisper.RotateSignedPreKeyListener.stop(window.Whisper.events);
+ }
+
+ private async register(language: string) {
+ const { password, mnemonicSeed, displayName } = this.state;
+ // Make sure the password is valid
+ if (this.validatePassword()) {
+ //this.showToast(window.i18n('invalidPassword'));
+ return;
+ }
+ if (!mnemonicSeed) {
+ return;
+ }
+ if (!displayName) {
+ return;
+ }
+
+ // Ensure we clear the secondary device registration status
+ window.textsecure.storage.remove('secondaryDeviceStatus');
+
+ try {
+ await this.resetRegistration();
+
+ await window.setPassword(password);
+ await this.accountManager.registerSingleDevice(
+ mnemonicSeed,
+ language,
+ displayName
+ );
+ trigger('openInbox');
+ } catch (e) {
+ if (typeof e === 'string') {
+ //this.showToast(e);
+ }
+ //this.log(e);
+ }
+ }
+
+ private async cancelSecondaryDevice() {
+ window.Whisper.events.off(
+ 'secondaryDeviceRegistration',
+ this.onSecondaryDeviceRegistered
+ );
+
+ await this.resetRegistration();
+ }
+
+ private async registerSecondaryDevice() {
+ // tslint:disable-next-line: no-backbone-get-set-outside-model
+ if (window.textsecure.storage.get('secondaryDeviceStatus') === 'ongoing') {
+ return;
+ }
+ await this.resetRegistration();
+ window.textsecure.storage.put('secondaryDeviceStatus', 'ongoing');
+
+ const primaryPubKey = this.state.primaryDevicePubKey;
+
+ // Ensure only one listener
+ window.Whisper.events.off(
+ 'secondaryDeviceRegistration',
+ this.onSecondaryDeviceRegistered
+ );
+ window.Whisper.events.once(
+ 'secondaryDeviceRegistration',
+ this.onSecondaryDeviceRegistered
+ );
+
+ const onError = async (error: any) => {
+ window.console.error(error);
+
+ await this.resetRegistration();
+ };
+
+ const c = new window.Whisper.Conversation({
+ id: primaryPubKey,
+ type: 'private',
+ });
+
+ const validationError = c.validateNumber();
+ if (validationError) {
+ onError('Invalid public key').ignore();
+
+ return;
+ }
+ try {
+ const fakeMnemonic = this.state.mnemonicSeed;
+
+ await this.accountManager.registerSingleDevice(
+ fakeMnemonic,
+ 'english',
+ null
+ );
+
+ await this.accountManager.requestPairing(primaryPubKey);
+ const pubkey = window.textsecure.storage.user.getNumber();
+ const words = window.mnemonic.pubkey_to_secret_words(pubkey);
+ window.console.log('pubkey_to_secret_words');
+ window.console.log(`Here is your secret:\n${words}`);
+ } catch (e) {
+ window.console.log(e);
+ //onError(e);
+ }
+ }
+
+ private async onSecondaryDeviceRegistered() {
+ // Ensure the left menu is updated
+ trigger('userChanged', { isSecondaryDevice: true });
+ // will re-run the background initialisation
+ trigger('registration_done');
+ trigger('openInbox');
+ }
+}
diff --git a/ts/components/session/SessionButton.tsx b/ts/components/session/SessionButton.tsx
index 587a7d522..62b0aebd2 100644
--- a/ts/components/session/SessionButton.tsx
+++ b/ts/components/session/SessionButton.tsx
@@ -1,8 +1,6 @@
import React from 'react';
import classNames from 'classnames';
-//import { LocalizerType } from '../../types/Util';
-
export enum SessionButtonType {
Brand = 'brand',
BrandOutline = 'brand-outline',
@@ -23,7 +21,6 @@ export enum SessionButtonColor {
}
interface Props {
- //i18n: LocalizerType;
text: string;
buttonType: SessionButtonType;
buttonColor: SessionButtonColor;
@@ -45,13 +42,18 @@ export class SessionButton extends React.PureComponent {
public render() {
const { buttonType, buttonColor, text } = this.props;
+ const buttonTypes = [];
+
+ buttonTypes.push(buttonType);
+ if (buttonType.includes('-outline')) {
+ buttonTypes.push(buttonType.replace('-outline', ''));
+ }
+
return (
= ({
+ tag = 'div',
+ key,
+ html,
+}) => {
+ const clean = DOMPurify.sanitize(html, {
+ USE_PROFILES: { html: true },
+ FORBID_ATTR: ['style', 'script'],
+ });
+
+ return React.createElement(tag, {
+ key,
+ dangerouslySetInnerHTML: { __html: clean },
+ });
+};
diff --git a/ts/components/session/SessionInput.tsx b/ts/components/session/SessionInput.tsx
new file mode 100644
index 000000000..b4789ae9a
--- /dev/null
+++ b/ts/components/session/SessionInput.tsx
@@ -0,0 +1,103 @@
+import React from 'react';
+
+import classNames from 'classnames';
+import { SessionIconButton, SessionIconSize, SessionIconType } from './icon';
+
+interface Props {
+ label: string;
+ type: string;
+ value?: string;
+ placeholder: string;
+ enableShowHide?: boolean;
+ onValueChanged?: any;
+ onEnterPressed?: any;
+}
+
+interface State {
+ inputValue: string;
+ forceShow: boolean;
+}
+
+export class SessionInput extends React.PureComponent {
+ constructor(props: any) {
+ super(props);
+
+ this.updateInputValue = this.updateInputValue.bind(this);
+ this.renderShowHideButton = this.renderShowHideButton.bind(this);
+
+ this.state = {
+ inputValue: '',
+ forceShow: false,
+ };
+ }
+
+ public render() {
+ const { placeholder, type, label, value, enableShowHide } = this.props;
+ const { inputValue, forceShow } = this.state;
+
+ const correctType = forceShow ? 'text' : type;
+
+ return (
+ {
+ this.setState({
+ forceShow: !this.state.forceShow,
+ });
+ }}
+ />
+ );
+ }
+
+ private updateInputValue(e: any) {
+ e.preventDefault();
+ this.setState({
+ inputValue: e.target.value,
+ });
+
+ if (this.props.onValueChanged) {
+ this.props.onValueChanged(e.target.value);
+ }
+ }
+}
diff --git a/ts/components/session/SessionRegistrationView.tsx b/ts/components/session/SessionRegistrationView.tsx
new file mode 100644
index 000000000..3da95f6b5
--- /dev/null
+++ b/ts/components/session/SessionRegistrationView.tsx
@@ -0,0 +1,30 @@
+import React from 'react';
+import { AccentText } from './AccentText';
+
+import { RegistrationTabs } from './RegistrationTabs';
+import { SessionIconButton, SessionIconSize, SessionIconType } from './icon';
+
+export const SessionRegistrationView: React.FC = () => (
+ {
+ ignore(): void;
+}
diff --git a/tslint.json b/tslint.json
index b114819d2..84c0bb5c3 100644
--- a/tslint.json
+++ b/tslint.json
@@ -141,9 +141,9 @@
"react-no-dangerous-html": [
true,
{
- "file": "ts/components/conversation/Linkify.tsx",
- "method": "render",
- "comment": "Usage has been approved by Ryan Tharp on 2019-07-22"
+ "file": "ts/components/session/SessionHTMLRenderer.tsx",
+ "method": "",
+ "comment": "Usage has been approved by Maxim on 13 Dec 2019"
}
],
// Reasonable functions can exceed the default of 100 lines
diff --git a/yarn.lock b/yarn.lock
index 6aa154576..75bf08394 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -138,6 +138,13 @@
resolved "https://registry.yarnpkg.com/@types/debug/-/debug-4.1.5.tgz#b14efa8852b7768d898906613c23f688713e02cd"
integrity sha512-Q1y515GcOdTHgagaVFhHnIFQ38ygs/kmxdNpvpou+raI9UO3YZcHDngBSYKQklcKlvA7iuQlmIKbzvmxcOE9CQ==
+"@types/dompurify@^2.0.0":
+ version "2.0.0"
+ resolved "https://registry.yarnpkg.com/@types/dompurify/-/dompurify-2.0.0.tgz#9616caa5bf2569aea2e4889d4f929d968c081b40"
+ integrity sha512-g/ilp+Bo6Ljy60i5LnjkGw00X7EIoFjoPGlxqZhV8TJ9fWEzXheioU1O+U/UzCzUA7pUDy/JNMytTQDJctpUHg==
+ dependencies:
+ "@types/trusted-types" "*"
+
"@types/events@*":
version "3.0.0"
resolved "https://registry.yarnpkg.com/@types/events/-/events-3.0.0.tgz#2862f3f58a9a7f7c3e78d79f130dd4d71c25c2a7"
@@ -324,6 +331,11 @@
resolved "https://registry.yarnpkg.com/@types/tough-cookie/-/tough-cookie-2.3.5.tgz#9da44ed75571999b65c37b60c9b2b88db54c585d"
integrity sha512-SCcK7mvGi3+ZNz833RRjFIxrn4gI1PPR3NtuIS+6vMkvmsGjosqTJwRt5bAEFLRz+wtJMWv8+uOnZf2hi2QXTg==
+"@types/trusted-types@*":
+ version "1.0.4"
+ resolved "https://registry.yarnpkg.com/@types/trusted-types/-/trusted-types-1.0.4.tgz#922d092c84a776a59acb0bd6785fd82b59b9bad5"
+ integrity sha512-6jtHrHpmiXOXoJ31Cg9R+iEVwuEKPf0XHwFUI93eEPXx492/J2JHyafkleKE2EYzZprayk9FSjTyK1GDqcwDng==
+
"@types/uuid@3.4.4":
version "3.4.4"
resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-3.4.4.tgz#7af69360fa65ef0decb41fd150bf4ca5c0cefdf5"
@@ -2581,6 +2593,11 @@ domain-browser@^1.1.1:
version "1.2.0"
resolved "https://registry.yarnpkg.com/domain-browser/-/domain-browser-1.2.0.tgz#3d31f50191a6749dd1375a7f522e823d42e54eda"
+dompurify@^2.0.7:
+ version "2.0.7"
+ resolved "https://registry.yarnpkg.com/dompurify/-/dompurify-2.0.7.tgz#f8266ad38fe1602fb5b3222f31eedbf5c16c4fd5"
+ integrity sha512-S3O0lk6rFJtO01ZTzMollCOGg+WAtCwS3U5E2WSDY/x/sy7q70RjEC4Dmrih5/UqzLLB9XoKJ8KqwBxaNvBu4A==
+
dot-prop@^4.1.0:
version "4.1.1"
resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-4.1.1.tgz#a8493f0b7b5eeec82525b5c7587fa7de7ca859c1"
+ {this.renderRestoreUsingSeedButton(
+ SessionButtonType.BrandOutline,
+ SessionButtonColor.Green
+ )}
+
+ );
+ }
+
+ if (signInMode === SignInMode.LinkingDevice) {
+ return (
+ {or}
+ {this.renderLinkDeviceToExistingAccountButton()}
+
+ {this.renderContinueYourSessionButton()}
+
+ );
+ }
+
+ return (
+ {or}
+ {this.renderRestoreUsingSeedButton(
+ SessionButtonType.BrandOutline,
+ SessionButtonColor.Green
+ )}
+
+ {this.renderContinueYourSessionButton()}
+
+ );
+ }
+
+ private renderTermsConditionAgreement() {
+ // FIXME link to our Terms and Conditions and privacy statement
+
+ return (
+ {or}
+ {this.renderLinkDeviceToExistingAccountButton()}
+
+
+ );
+ }
+
+ private handleContinueYourSessionClick() {
+ if (this.state.signInMode === SignInMode.UsingSeed) {
+ this.register('english').ignore();
+ } else {
+ this.registerSecondaryDevice().ignore();
+ }
+ }
+
+ private renderContinueYourSessionButton() {
+ return (
+ {
- this.clickHandler(e);
- }}
- className={classNames('session-button', buttonType, buttonColor)}
+ className={classNames('session-button', ...buttonTypes, buttonColor)}
role="button"
+ onClick={this.clickHandler}
>
{text}
diff --git a/ts/components/session/SessionHTMLRenderer.tsx b/ts/components/session/SessionHTMLRenderer.tsx
new file mode 100644
index 000000000..24e7c4bc8
--- /dev/null
+++ b/ts/components/session/SessionHTMLRenderer.tsx
@@ -0,0 +1,26 @@
+import React from 'react';
+import DOMPurify from 'dompurify';
+
+interface ReceivedProps {
+ html: string;
+ tag?: string;
+ key?: any;
+}
+
+type Props = ReceivedProps;
+
+export const SessionHtmlRenderer: React.SFC
+
+ {
+ this.updateInputValue(e);
+ }}
+ className={classNames(
+ enableShowHide ? 'session-input-floating-label-show-hide' : ''
+ )}
+ onKeyPress={event => {
+ event.persist();
+ if (event.key === 'Enter' && this.props.onEnterPressed) {
+ this.props.onEnterPressed();
+ }
+ }}
+ />
+
+ {enableShowHide && this.renderShowHideButton()}
+
+
+
+ );
+ }
+
+ private renderShowHideButton() {
+ return (
+ +
+
+
+);
diff --git a/ts/global.d.ts b/ts/global.d.ts
new file mode 100644
index 000000000..5817c1f87
--- /dev/null
+++ b/ts/global.d.ts
@@ -0,0 +1,19 @@
+interface Window {
+ getAccountManager: any;
+ mnemonic: any;
+ passwordUtil: any;
+ dcodeIO: any;
+ libsignal: any;
+ displayNameRegex: any;
+ Signal: any;
+ Whisper: any;
+ ConversationController: any;
+ setPassword: any;
+ textsecure: any;
+ Session: any;
+ i18n: any;
+}
+
+interface Promise
+ {
+ window.close();
+ }}
+ />
+
+
+
+
+
+
+
+ 
+
+
+