v21.0.0

Co-authored-by: Michael Telatynski <7t3chguy@gmail.com>

.babelrc

@@ -0,0 +1,19 @@
+{
+    "sourceMaps": true,
+    "presets": [
+        ["@babel/preset-env", {
+            "targets": {
+                "node": 10
+            },
+            "modules": "commonjs"
+        }],
+        "@babel/preset-typescript"
+    ],
+    "plugins": [
+        "@babel/plugin-proposal-numeric-separator",
+        "@babel/plugin-proposal-class-properties",
+        "@babel/plugin-proposal-object-rest-spread",
+        "@babel/plugin-syntax-dynamic-import",
+        "@babel/plugin-transform-runtime"
+    ]
+}

.editorconfig

@@ -0,0 +1,26 @@
+#   Copyright 2017 Aviral Dasgupta
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+
+root = true
+
+[*]
+charset=utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+
+[*.{yml,yaml}]
+indent_size = 2

.eslintrc.js

@@ -0,0 +1,89 @@
+module.exports = {
+    plugins: [
+        "matrix-org",
+        "import",
+    ],
+    extends: [
+        "plugin:matrix-org/babel",
+        "plugin:import/typescript",
+    ],
+    env: {
+        browser: true,
+        node: true,
+    },
+    settings: {
+        "import/resolver": {
+            typescript: true,
+            node: true,
+        },
+    },
+    // NOTE: These rules are frozen and new rules should not be added here.
+    // New changes belong in https://github.com/matrix-org/eslint-plugin-matrix-org/
+    rules: {
+        "no-var": ["warn"],
+        "prefer-rest-params": ["warn"],
+        "prefer-spread": ["warn"],
+        "one-var": ["warn"],
+        "padded-blocks": ["warn"],
+        "no-extend-native": ["warn"],
+        "camelcase": ["warn"],
+        "no-multi-spaces": ["error", { "ignoreEOLComments": true }],
+        "space-before-function-paren": ["error", {
+            "anonymous": "never",
+            "named": "never",
+            "asyncArrow": "always",
+        }],
+        "arrow-parens": "off",
+        "prefer-promise-reject-errors": "off",
+        "quotes": "off",
+        "indent": "off",
+        "no-constant-condition": "off",
+        "no-async-promise-executor": "off",
+        // We use a `logger` intermediary module
+        "no-console": "error",
+
+        // restrict EventEmitters to force callers to use TypedEventEmitter
+        "no-restricted-imports": ["error", {
+            name: "events",
+            message: "Please use TypedEventEmitter instead"
+        }],
+
+        "import/no-restricted-paths": ["error", {
+            "zones": [{
+                "target": "./src/",
+                "from": "./src/index.ts",
+                "message": "The package index is dynamic between src and lib depending on " +
+                    "whether release or development, target the specific module or matrix.ts instead",
+            }],
+        }],
+    },
+    overrides: [{
+        files: [
+            "**/*.ts",
+        ],
+        extends: [
+            "plugin:matrix-org/typescript",
+        ],
+        rules: {
+            // TypeScript has its own version of this
+            "@babel/no-invalid-this": "off",
+
+            // We're okay being explicit at the moment
+            "@typescript-eslint/no-empty-interface": "off",
+            // We disable this while we're transitioning
+            "@typescript-eslint/no-explicit-any": "off",
+            // We'd rather not do this but we do
+            "@typescript-eslint/ban-ts-comment": "off",
+            // We're okay with assertion errors when we ask for them
+            "@typescript-eslint/no-non-null-assertion": "off",
+
+            // The non-TypeScript rule produces false positives
+            "func-call-spacing": "off",
+            "@typescript-eslint/func-call-spacing": ["error"],
+
+            "quotes": "off",
+            // We use a `logger` intermediary module
+            "no-console": "error",
+        },
+    }],
+};

.git-blame-ignore-revs

@@ -0,0 +1,41 @@
+# Minor white-space adjustments
+1d1d59c75744e1f6a2be1cb3e0d1bd9ded5f8025
+# Import ordering and spacing: eslint-plugin-import
+80aaa6c32b50601f82e0c991c24e5a4590f39463
+# Minor white-space adjustment
+8fb036ba2d01fab66dc4373802ccf19b5cac8541
+# Minor white-space adjustment
+b63de6a902a9e1f8ffd7697dea33820fc04f028e
+3ca84cfc491b0987eec1f13f13cae58d2032bf54
+# Conform to new typescript eslint rules
+a87858840b57514603f63e2abbbda4f107f05a77
+5cf6684129a921295f5593173f16f192336fe0a2
+# Comply with new member-delimiter-style rule
+b2ad957d298720d3e026b6bd91be0c403338361a
+# Fix semicolons in TS files
+e2ec8952e38b8fea3f0ccaa09ecb42feeba0d923
+# Migrate to `eslint-plugin-matrix-org`
+# and `babel/...` to `@babel/...` migration
+09fac77ce0d9bcf6637088c29afab84084f0e739
+102704e91a70643bcc09721e14b0d909f0ef55c6
+# Eslint formatting
+cec00cd303787fa9008b6c48826e75ed438036fa
+# Minor eslint changes
+68bb8182e4e62d8f450f80c408c4b231b8725f1b
+c979ff6696e30ab8983ac416a3590996d84d3560
+f4a7395e3a3751a1a8e92dd302c49175a3296ad2
+# eslint --fix for dangley commas on function calls
+423175f5397910b0afe3112d6fb18283fc7d27d4
+# eslint ---fix for prefer-const
+7bca05af644e8b997dae81e568a3913d8f18d7ca
+# Fix linting on tests
+cee7f7a280a8c20bafc21c0a2911f60851f7a7ca
+# eslint --fix
+0fa9f7c6098822db1ae214f352fd1fe5c248b02c
+# eslint --fix for lots of white-space
+5abf6b9f208801c5022a47023150b5846cb0b309
+# eslint --fix
+7ed65407e6cdf292ce3cf659310c68d19dcd52b2
+# Switch to ESLint from JSHint (Google eslint rules as a base)
+e057956ede9ad1a931ff8050c411aca7907e0394
+

.github/CODEOWNERS

@@ -0,0 +1 @@
+* @matrix-org/element-web

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+patreon: matrixdotorg
+liberapay: matrixdotorg

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,13 @@
+<!-- Thanks for submitting a PR! Please ensure the following requirements are met in order for us to review your PR -->
+
+## Checklist
+
+* [ ] Tests written for new code (and old code if feasible)
+* [ ] Linter and other CI checks pass
+* [ ] Sign-off given on the changes (see [CONTRIBUTING.md](https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md))
+
+<!--
+If you would like to specify text for the changelog entry other than your PR title, add the following:
+
+Notes: Add super cool feature
+-->

.github/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "github>matrix-org/renovate-config-element-web"
+  ]
+}

.github/workflows/backport.yml

@@ -0,0 +1,30 @@
+name: Backport
+on:
+  pull_request_target:
+    types:
+      - closed
+      - labeled
+    branches:
+      - develop
+
+jobs:
+  backport:
+    name: Backport
+    runs-on: ubuntu-latest
+    # Only react to merged PRs for security reasons.
+    # See https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target.
+    if: >
+      github.event.pull_request.merged
+      && (
+        github.event.action == 'closed'
+        || (
+          github.event.action == 'labeled'
+          && contains(github.event.label.name, 'backport')
+        )
+      )
+    steps:
+      - uses: tibdex/backport@v2
+        with:
+          labels_template: "<%= JSON.stringify([...labels, 'X-Release-Blocker']) %>"
+          # We can't use GITHUB_TOKEN here or CI won't run on the new PR
+          github_token: ${{ secrets.ELEMENT_BOT_TOKEN }}

.github/workflows/notify-downstream.yaml

@@ -0,0 +1,27 @@
+name: Notify Downstream Projects
+on:
+  push:
+    branches: [ develop ]
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  notify-downstream:
+    # Only respect triggers from our develop branch, ignore that of forks
+    if: github.repository == 'matrix-org/matrix-js-sdk'
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - repo: vector-im/element-web
+            event: element-web-notify
+          - repo: matrix-org/matrix-react-sdk
+            event: upstream-sdk-notify
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify matrix-react-sdk repo that a new SDK build is on develop so it can CI against it
+        uses: peter-evans/repository-dispatch@v2
+        with:
+          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+          repository: ${{ matrix.repo }}
+          event-type: ${{ matrix.event }}

.github/workflows/pull_request.yaml

@@ -0,0 +1,91 @@
+name: Pull Request
+on:
+  pull_request_target:
+    types: [ opened, edited, labeled, unlabeled, synchronize ]
+  workflow_call:
+    inputs:
+      labels:
+        type: string
+        default: "T-Defect,T-Deprecation,T-Enhancement,T-Task"
+        required: false
+        description: "No longer used, uses allchange logic now, will be removed at a later date"
+    secrets:
+      ELEMENT_BOT_TOKEN:
+        required: true
+concurrency: ${{ github.workflow }}-${{ github.event.pull_request.head.ref }}
+jobs:
+  changelog:
+    name: Preview Changelog
+    runs-on: ubuntu-latest
+    steps:
+      - uses: matrix-org/allchange@main
+        with:
+          ghToken: ${{ secrets.GITHUB_TOKEN }}
+          requireLabel: true
+
+  prevent-blocked:
+    name: Prevent Blocked
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    steps:
+      - name: Add notice
+        uses: actions/github-script@v6
+        if: contains(github.event.pull_request.labels.*.name, 'X-Blocked')
+        with:
+          script: |
+            core.setFailed("Preventing merge whilst PR is marked blocked!");
+
+  community-prs:
+    name: Label Community PRs
+    runs-on: ubuntu-latest
+    if: github.event.action == 'opened'
+    steps:
+      - name: Check membership
+        uses: tspascoal/get-user-teams-membership@v1
+        id: teams
+        with:
+          username: ${{ github.event.pull_request.user.login }}
+          organization: matrix-org
+          team: Core Team
+          GITHUB_TOKEN: ${{ secrets.ELEMENT_BOT_TOKEN }}
+
+      - name: Add label
+        if: ${{ steps.teams.outputs.isTeamMember == 'false' }}
+        uses: actions/github-script@v6
+        with:
+          script: |
+            github.rest.issues.addLabels({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              labels: ['Z-Community-PR']
+            });
+
+  close-if-fork-develop:
+    name: Forbid develop branch fork contributions
+    runs-on: ubuntu-latest
+    if: >
+      github.event.action == 'opened' &&
+      github.event.pull_request.head.ref == 'develop' &&
+      github.event.pull_request.head.repo.full_name != github.repository
+    steps:
+      - name: Close pull request
+        uses: actions/github-script@v6
+        with:
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: "Thanks for opening this pull request, unfortunately we do not accept contributions from the main" +
+                " branch of your fork, please re-open once you switch to an alternative branch for everyone's sanity." +
+                " See https://github.com/matrix-org/matrix-js-sdk/blob/develop/CONTRIBUTING.md",
+            });
+
+            github.rest.pulls.update({
+              pull_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: 'closed'
+            });

.github/workflows/release-npm.yml

@@ -0,0 +1,41 @@
+# Must only be called from `release#published` triggers
+name: Publish to npm
+on:
+  workflow_call:
+    secrets:
+      NPM_TOKEN:
+        required: true
+jobs:
+  npm:
+    name: Publish to npm
+    runs-on: ubuntu-latest
+    steps:
+      - name: 🧮 Checkout code
+        uses: actions/checkout@v3
+
+      - name: 🔧 Yarn cache
+        uses: actions/setup-node@v3
+        with:
+          cache: "yarn"
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: 🔨 Install dependencies
+        run: "yarn install --pure-lockfile"
+
+      - name: 🚀 Publish to npm
+        id: npm-publish
+        uses: JS-DevTools/npm-publish@v1
+        with:
+          token: ${{ secrets.NPM_TOKEN }}
+          access: public
+          tag: next
+
+      - name: 🎖️ Add `latest` dist-tag to final releases
+        if: github.event.release.prerelease == false
+        run: |
+          package=$(cat package.json | jq -er .name)
+          npm dist-tag add "$package@$release" latest
+        env:
+          # JS-DevTools/npm-publish overrides `NODE_AUTH_TOKEN` with `INPUT_TOKEN` in .npmrc
+          INPUT_TOKEN: ${{ secrets.NPM_TOKEN }}
+          release: ${{ steps.npm-publish.outputs.version }}

.github/workflows/release.yml

@@ -0,0 +1,58 @@
+name: Release Process
+on:
+  release:
+    types: [ published ]
+concurrency: ${{ github.workflow }}-${{ github.ref }}
+jobs:
+  jsdoc:
+    name: Publish Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: 🧮 Checkout code
+        uses: actions/checkout@v3
+
+      - name: 🔧 Yarn cache
+        uses: actions/setup-node@v3
+        with:
+          cache: "yarn"
+
+      - name: 🔨 Install dependencies
+        run: "yarn install --pure-lockfile"
+
+      - name: 📖 Generate JSDoc
+        run: "yarn gendoc"
+
+      - name: 📋 Copy to temp
+        run: |
+          tag="${{ github.ref_name }}"
+          version="${tag#v}"
+          echo "VERSION=$version" >> $GITHUB_ENV
+          cp -a "./.jsdoc/matrix-js-sdk/$version" $RUNNER_TEMP
+
+      - name: 🧮 Checkout gh-pages
+        uses: actions/checkout@v3
+        with:
+          ref: gh-pages
+
+      - name: 🔪 Prepare
+        run: |
+          cp -a "$RUNNER_TEMP/$VERSION" .
+
+          # Add the new directory to the index if it isn't there already
+          if ! grep -q ">Version $VERSION</a>" index.html; then
+            perl -i -pe 'BEGIN {$rel=shift} $_ =~ /^<\/ul>/ && print
+              "<li><a href=\"${rel}/index.html\">Version ${rel}</a></li>\n"' "$VERSION" index.html
+          fi
+
+      - name: 🚀 Deploy
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          keep_files: true
+          publish_dir: .
+
+  npm:
+    name: Publish
+    uses: matrix-org/matrix-js-sdk/.github/workflows/release-npm.yml@develop
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/sonarcloud.yml

@@ -0,0 +1,45 @@
+# Must only be called from a workflow_run in the context of the upstream repo
+name: SonarCloud
+on:
+  workflow_call:
+    secrets:
+      SONAR_TOKEN:
+        required: true
+jobs:
+  sonarqube:
+    runs-on: ubuntu-latest
+    if: github.event.workflow_run.conclusion == 'success'
+    steps:
+      # We create the status here and then update it to success/failure in the `report` stage
+      # This provides an easy link to this workflow_run from the PR before Cypress is done.
+      - uses: Sibz/github-status-action@v1
+        with:
+          authToken: ${{ secrets.GITHUB_TOKEN }}
+          state: pending
+          context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+          sha: ${{ github.event.workflow_run.head_sha }}
+          target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}
+
+      - name: "🩻 SonarCloud Scan"
+        id: sonarcloud
+        uses: matrix-org/sonarcloud-workflow-action@v2.2
+        with:
+          repository: ${{ github.event.workflow_run.head_repository.full_name }}
+          is_pr: ${{ github.event.workflow_run.event == 'pull_request' }}
+          version_cmd: 'cat package.json | jq -r .version'
+          branch: ${{ github.event.workflow_run.head_branch }}
+          revision: ${{ github.event.workflow_run.head_sha }}
+          token: ${{ secrets.SONAR_TOKEN }}
+          coverage_run_id: ${{ github.event.workflow_run.id }}
+          coverage_workflow_name: tests.yml
+          coverage_extract_path: coverage
+          
+      
+      - uses: Sibz/github-status-action@v1
+        if: always()
+        with:
+          authToken: ${{ secrets.GITHUB_TOKEN }}
+          state: ${{ steps.sonarcloud.outcome == 'success' && 'success' || 'failure' }}
+          context: ${{ github.workflow }} / SonarCloud (${{ github.event.workflow_run.event }} => ${{ github.event_name }})
+          sha: ${{ github.event.workflow_run.head_sha }}
+          target_url: https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}

.github/workflows/sonarqube.yml

@@ -0,0 +1,15 @@
+name: SonarQube
+on:
+  workflow_run:
+    workflows: [ "Tests" ]
+    types:
+      - completed
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.workflow_run.head_branch }}
+  cancel-in-progress: true
+jobs:
+  sonarqube:
+    name: 🩻 SonarQube
+    uses: matrix-org/matrix-js-sdk/.github/workflows/sonarcloud.yml@develop
+    secrets:
+      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.github/workflows/static_analysis.yml

@@ -0,0 +1,101 @@
+name: Static Analysis
+on:
+  pull_request: { }
+  push:
+    branches: [ develop, master ]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  ts_lint:
+    name: "Typescript Syntax Check"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Typecheck
+        run: "yarn run lint:types"
+
+      - name: Switch js-sdk to release mode
+        run: |
+          scripts/switch_package_to_release.js
+          yarn install
+          yarn run build:compile
+          yarn run build:types
+
+      - name: Typecheck (release mode)
+        run: "yarn run lint:types"
+
+  js_lint:
+    name: "ESLint"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Run Linter
+        run: "yarn run lint:js"
+
+  docs:
+    name: "JSDoc Checker"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install Deps
+        run: "yarn install"
+
+      - name: Generate Docs
+        run: "yarn run gendoc"
+
+  tsc-strict:
+    name: Typescript Strict Error Checker
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+      checks: write
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Get diff lines
+        id: diff
+        uses: Equip-Collaboration/diff-line-numbers@v1.0.0
+        with:
+          include: '["\\.tsx?$"]'
+
+      - name: Detecting files changed
+        id: files
+        uses: futuratrepadeira/changed-files@v4.0.0
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          pattern: '^.*\.tsx?$'
+
+      - uses: t3chguy/typescript-check-action@main
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          use-check: false
+          check-fail-mode: added
+          output-behaviour: annotate
+          ts-extra-args: '--strict'
+          files-changed: ${{ steps.files.outputs.files_updated }}
+          files-added: ${{ steps.files.outputs.files_created }}
+          files-deleted: ${{ steps.files.outputs.files_deleted }}
+          line-numbers: ${{ steps.diff.outputs.lineNumbers }}

.github/workflows/tests.yml

@@ -0,0 +1,37 @@
+name: Tests
+on:
+  pull_request: { }
+  push:
+    branches: [ develop, master ]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  jest:
+    name: Jest
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Yarn cache
+        uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Install dependencies
+        run: "yarn install"
+
+      - name: Build
+        run: "yarn build"
+
+      - name: Run tests with coverage
+        run: "yarn coverage --ci --reporters github-actions"
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: coverage
+          path: |
+            coverage
+            !coverage/lcov-report

.github/workflows/upgrade_dependencies.yml

@@ -0,0 +1,38 @@
+name: Upgrade Dependencies
+on:
+  workflow_dispatch: { }
+  workflow_call:
+    secrets:
+      ELEMENT_BOT_TOKEN:
+        required: true
+jobs:
+  upgrade:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/setup-node@v3
+        with:
+          cache: 'yarn'
+
+      - name: Upgrade
+        run: yarn upgrade && yarn install
+
+      - name: Create Pull Request
+        id: cpr
+        uses: peter-evans/create-pull-request@v4
+        with:
+          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+          branch: actions/upgrade-deps
+          delete-branch: true
+          title: Upgrade dependencies
+          labels: |
+            Dependencies
+            T-Task
+          
+      - name: Enable automerge
+        uses: peter-evans/enable-pull-request-automerge@v2
+        if: steps.cpr.outputs.pull-request-operation == 'created'
+        with:
+          token: ${{ secrets.ELEMENT_BOT_TOKEN }}
+          pull-request-number: ${{ steps.cpr.outputs.pull-request-number }}

.gitignore

@@ -1,15 +1,21 @@
-# Keep this file in sync with .npmignore.
+/.jsdocbuild
+/.jsdoc
 
-.jsdoc
 node_modules
+/.npmrc
+/*.log
+package-lock.json
 .lock-wscript
 build/Release
 coverage
 lib-cov
 out
-reports
-dist/browser-matrix-dev.js
+/dist
+/lib
 
-# version file and tarball created by 'npm pack'
+# version file and tarball created by `npm pack` / `yarn pack`
 /git-revision.txt
 /matrix-js-sdk-*.tgz
+
+.vscode
+.vscode/

.istanbul.yml

@@ -1,2 +0,0 @@
-instrumentation:
-  compact: false

.jshint

@@ -1,11 +0,0 @@
-{
-    "node": true,
-    "jasmine": true,
-
-    "nonew": true,
-    "curly": true,
-    "forin": true,
-    "freeze": false,
-    "undef": true,
-    "unused": "vars"
-}

.npmignore

@@ -1,15 +0,0 @@
-# Keep this file in sync with .gitignore.
-
-.jsdoc
-node_modules
-.lock-wscript
-build/Release
-coverage
-lib-cov
-out
-reports
-dist/browser-matrix-dev.js
-
-# tarball created by 'npm pack'.
-/matrix-js-sdk-*.tgz
-

CONTRIBUTING.md

@@ -0,0 +1,5 @@
+Contributing code to matrix-js-sdk
+==================================
+
+matrix-js-sdk follows the same pattern as https://github.com/vector-im/element-web/blob/develop/CONTRIBUTING.md
+

README.md

@@ -1,8 +1,15 @@
+[![npm](https://img.shields.io/npm/v/matrix-js-sdk)](https://www.npmjs.com/package/matrix-js-sdk)
+![Tests](https://github.com/matrix-org/matrix-js-sdk/actions/workflows/tests.yml/badge.svg)
+![Static Analysis](https://github.com/matrix-org/matrix-js-sdk/actions/workflows/static_analysis.yml/badge.svg)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=coverage)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+[![Bugs](https://sonarcloud.io/api/project_badges/measure?project=matrix-js-sdk&metric=bugs)](https://sonarcloud.io/summary/new_code?id=matrix-js-sdk)
+
 Matrix Javascript SDK
 =====================
-[![Build Status](http://matrix.org/jenkins/buildStatus/icon?job=JavascriptSDK)](http://matrix.org/jenkins/job/JavascriptSDK/)
 
-This is the [Matrix](https://matrix.org) Client-Server v1/v2 alpha SDK for
+This is the [Matrix](https://matrix.org) Client-Server r0 SDK for
 JavaScript. This SDK can be run in a browser or in Node.js.
 
 Quickstart
@@ -10,26 +17,92 @@ Quickstart
 
 In a browser
 ------------
-Copy ``dist/$VERSION/browser-matrix-$VERSION.js`` and add that as a ``<script>`` to
-your page. There will be a global variable ``matrixcs`` attached to
-``window`` through which you can access the SDK.
+Download the browser version from
+https://github.com/matrix-org/matrix-js-sdk/releases/latest and add that as a
+``<script>`` to your page. There will be a global variable ``matrixcs``
+attached to ``window`` through which you can access the SDK. See below for how to
+include libolm to enable end-to-end-encryption.
+
+The browser bundle supports recent versions of browsers. Typically this is ES2015
+or `> 0.5%, last 2 versions, Firefox ESR, not dead` if using
+[browserlists](https://github.com/browserslist/browserslist).
 
 Please check [the working browser example](examples/browser) for more information.
 
 In Node.js
 ----------
 
-``npm install matrix-js-sdk``
+Ensure you have the latest LTS version of Node.js installed.
+This library relies on `fetch` which is available in Node from v18.0.0 - it should work fine also with polyfills.
+If you wish to use a ponyfill or adapter of some sort then pass it as `fetchFn` to the MatrixClient constructor options.
+
+Using `yarn` instead of `npm` is recommended. Please see the Yarn [install guide](https://classic.yarnpkg.com/en/docs/install)
+if you do not have it already.
+
+``yarn add matrix-js-sdk``
 
 ```javascript
-  var sdk = require("matrix-js-sdk");
-  var client = sdk.createClient("https://matrix.org");
+  import * as sdk from "matrix-js-sdk";
+  const client = sdk.createClient("https://matrix.org");
   client.publicRooms(function(err, data) {
     console.log("Public Rooms: %s", JSON.stringify(data));
   });
 ```
 
-Please check [the Node.js terminal app](examples/node) for a more complex example.
+See below for how to include libolm to enable end-to-end-encryption. Please check
+[the Node.js terminal app](examples/node) for a more complex example.
+
+To start the client:
+
+```javascript
+await client.startClient({initialSyncLimit: 10});
+```
+
+You can perform a call to `/sync` to get the current state of the client:
+
+```javascript
+client.once('sync', function(state, prevState, res) {
+    if(state === 'PREPARED') {
+        console.log("prepared");
+    } else {
+        console.log(state);
+        process.exit(1);
+    }
+});
+```
+
+To send a message:
+
+```javascript
+const content = {
+    "body": "message text",
+    "msgtype": "m.text"
+};
+client.sendEvent("roomId", "m.room.message", content, "", (err, res) => {
+    console.log(err);
+});
+```
+
+To listen for message events:
+
+```javascript
+client.on("Room.timeline", function(event, room, toStartOfTimeline) {
+  if (event.getType() !== "m.room.message") {
+    return; // only use messages
+  }
+  console.log(event.event.content.body);
+});
+```
+
+By default, the `matrix-js-sdk` client uses the `MemoryStore` to store events as they are received. For example to iterate through the currently stored timeline for a room:
+
+```javascript
+Object.keys(client.store.rooms).forEach((roomId) => {
+  client.getRoom(roomId).timeline.forEach(t => {
+      console.log(t.event);
+  });
+});
+```
 
 What does this SDK do?
 ----------------------
@@ -64,6 +137,7 @@ Later versions of the SDK will:
 Usage
 =====
 
+
 Conventions
 -----------
 
@@ -102,7 +176,7 @@ which will be fulfilled in the future.
 The typical usage is something like:
 
 ```javascript
-  matrixClient.someMethod(arg1, arg2).done(function(result) {
+  matrixClient.someMethod(arg1, arg2).then(function(result) {
     ...
   });
 ```
@@ -114,10 +188,8 @@ you can pass the result of the promise into it with something like:
   matrixClient.someMethod(arg1, arg2).nodeify(callback);
 ```
 
-The main thing to note is that it is an error to discard the result of a
-promise-returning function, as that will cause exceptions to go unobserved. If
-you have nothing better to do with the result, just call ``.done()`` on it. See
-http://documentup.com/kriskowal/q/#the-end for more information.
+The main thing to note is that it is problematic to discard the result of a
+promise-returning function, as that will cause exceptions to go unobserved.
 
 Methods which return a promise show this in their documentation.
 
@@ -132,10 +204,10 @@ This section provides some useful code snippets which demonstrate the
 core functionality of the SDK. These examples assume the SDK is setup like this:
 
 ```javascript
-   var sdk = require("matrix-js-sdk");
-   var myUserId = "@example:localhost";
-   var myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
-   var matrixClient = sdk.createClient({
+   import * as sdk from "matrix-js-sdk";
+   const myUserId = "@example:localhost";
+   const myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
+   const matrixClient = sdk.createClient({
        baseUrl: "http://localhost:8008",
        accessToken: myAccessToken,
        userId: myUserId
@@ -147,7 +219,7 @@ core functionality of the SDK. These examples assume the SDK is setup like this:
 ```javascript
    matrixClient.on("RoomMember.membership", function(event, member) {
        if (member.membership === "invite" && member.userId === myUserId) {
-           matrixClient.joinRoom(member.roomId).done(function() {
+           matrixClient.joinRoom(member.roomId).then(function() {
                console.log("Auto-joined %s", member.roomId);
            });
        }
@@ -188,11 +260,11 @@ Output:
 
 ```javascript
    matrixClient.on("RoomState.members", function(event, state, member) {
-       var room = matrixClient.getRoom(state.roomId);
+       const room = matrixClient.getRoom(state.roomId);
        if (!room) {
            return;
        }
-       var memberList = state.getMembers();
+       const memberList = state.getMembers();
        console.log(room.name);
        console.log(Array(room.name.length + 1).join("="));  // underline
        for (var i = 0; i < memberList.length; i++) {
@@ -227,13 +299,53 @@ This SDK uses JSDoc3 style comments. You can manually build and
 host the API reference from the source files like this:
 
 ```
-  $ npm run gendoc
+  $ yarn gendoc
   $ cd .jsdoc
   $ python -m SimpleHTTPServer 8005
 ```
 
 Then visit ``http://localhost:8005`` to see the API docs.
 
+End-to-end encryption support
+=============================
+
+The SDK supports end-to-end encryption via the Olm and Megolm protocols, using
+[libolm](https://gitlab.matrix.org/matrix-org/olm). It is left up to the
+application to make libolm available, via the ``Olm`` global.
+
+It is also necessary to call ``await matrixClient.initCrypto()`` after creating a new
+``MatrixClient`` (but **before** calling ``matrixClient.startClient()``) to
+initialise the crypto layer.
+
+If the ``Olm`` global is not available, the SDK will show a warning, as shown
+below; ``initCrypto()`` will also fail.
+
+```
+Unable to load crypto module: crypto will be disabled: Error: global.Olm is not defined
+```
+
+If the crypto layer is not (successfully) initialised, the SDK will continue to
+work for unencrypted rooms, but it will not support the E2E parts of the Matrix
+specification.
+
+To provide the Olm library in a browser application:
+
+ * download the transpiled libolm (from https://packages.matrix.org/npm/olm/).
+ * load ``olm.js`` as a ``<script>`` *before* ``browser-matrix.js``.
+
+To provide the Olm library in a node.js application:
+
+ * ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``
+   (replace the URL with the latest version you want to use from
+    https://packages.matrix.org/npm/olm/)
+ * ``global.Olm = require('olm');`` *before* loading ``matrix-js-sdk``.
+
+If you want to package Olm as dependency for your node.js application, you can
+use ``yarn add https://packages.matrix.org/npm/olm/olm-3.1.4.tgz``. If your
+application also works without e2e crypto enabled, add ``--optional`` to mark it
+as an optional dependency.
+
+
 Contributing
 ============
 *This section is for people who want to modify the SDK. If you just
@@ -241,7 +353,7 @@ want to use this SDK, skip this section.*
 
 First, you need to pull in the right build tools:
 ```
- $ npm install
+ $ yarn install
 ```
 
 Building
@@ -249,20 +361,15 @@ Building
 
 To build a browser version from scratch when developing::
 ```
- $ npm run build
-```
-
-To constantly do builds when files are modified (using ``watchify``)::
-```
- $ npm run watch
+ $ yarn build
 ```
 
 To run tests (Jasmine)::
 ```
- $ npm test
+ $ yarn test
 ```
 
 To run linting:
 ```
- $ npm run lint
+ $ yarn lint
 ```

RELEASING.md

@@ -1,14 +0,0 @@
-There is a script `release.sh` which does the following, but if you need to do
-a release manually, here are the steps:
-
-- `git checkout -b release-v0.x.x`
-- Update `CHANGELOG.md`
-- `npm version 0.x.x`
-- Merge `release-v0.x.x` onto `master`.
-- Push `master`.
-- Push the tag: `git push --tags`
-- `npm publish`
-- Generate documentation: `npm run gendoc` (this outputs HTML to `.jsdoc`)
-- Copy the documentation from `.jsdoc` to the `gh-pages` branch and update `index.html`
-- Merge `master` onto `develop`.
-- Push `develop`.

browser-index.js

@@ -1,4 +0,0 @@
-var matrixcs = require("./lib/matrix");
-matrixcs.request(require("browser-request"));
-module.exports = matrixcs; // keep export for browserify package deps
-global.matrixcs = matrixcs;

dist/README

@@ -1 +0,0 @@
-Release builds and development builds will reside here.

docs/storage-notes.md

@@ -0,0 +1,70 @@
+# Browser Storage Notes
+
+## Overview
+
+Browsers examined: Firefox 67, Chrome 75
+
+The examination below applies to the default, non-persistent storage policy.
+
+## Quota Measurement
+
+Browsers appear to enforce and measure the quota in terms of space on disk, not
+data stored, so you may be able to store more data than the simple sum of all
+input data depending on how compressible your data is.
+
+## Quota Limit
+
+Specs and documentation suggest we should consistently receive
+`QuotaExceededError` when we're near space limits, but the reality is a bit
+blurrier.
+
+When we are low on disk space overall or near the group limit / origin quota:
+
+* Chrome
+    * Log database may fail to start with AbortError
+    * IndexedDB fails to start for crypto: AbortError in connect from
+      indexeddb-store-worker
+    * When near the quota, QuotaExceededError is used more consistently
+* Firefox
+    * The first error will be QuotaExceededError
+    * Future write attempts will fail with various errors when space is low,
+      including nonsense like "InvalidStateError: A mutation operation was
+      attempted on a database that did not allow mutations."
+    * Once you start getting errors, the DB is effectively wedged in read-only
+      mode
+    * Can revive access if you reopen the DB
+
+## Cache Eviction
+
+While the Storage Standard says all storage for an origin group should be
+limited by a single quota, in practice, browsers appear to handle `localStorage`
+separately from the others, so it has a separate quota limit and isn't evicted
+when low on space.
+
+* Chrome, Firefox
+    * IndexedDB for origin deleted
+    * Local Storage remains in place
+
+## Persistent Storage
+
+Storage Standard offers a `navigator.storage.persist` API that can be used to
+request persistent storage that won't be deleted by the browser because of low
+space.
+
+* Chrome
+    * Chrome 75 seems to grant this without any prompt based on [interaction
+      criteria](https://developers.google.com/web/updates/2016/06/persistent-storage)
+* Firefox
+    * Firefox 67 shows a prompt to grant
+    * Reverting persistent seems to require revoking permission _and_ clearing
+      site data
+
+## Storage Estimation
+
+Storage Standard offers a `navigator.storage.estimate` API to get some clue of
+how much space remains.
+
+* Chrome, Firefox
+    * Can run this at any time to request an estimate of space remaining
+* Firefox
+    * Returns `0` for `usage` if a site is persisted

docs/warning-on-unverified-devices.txt

@@ -0,0 +1,31 @@
+Random notes from Matthew on the two possible approaches for warning users about unexpected
+unverified devices popping up in their rooms....
+
+Original idea...
+================
+
+Warn when an existing user adds an unknown device to a room.
+
+Warn when a user joins the room with unverified or unknown devices.
+
+Warn when you initial sync if the room has any unverified devices in it.
+ ^ this is good enough if we're doing local storage.
+ OR, better:
+Warn when you initial sync if the room has any new undefined devices since you were last there.
+ => This means persisting the rooms that devices are in, across initial syncs.
+
+
+Updated idea...
+===============
+
+Warn when the user tries to send a message:
+  - If the room has unverified devices which the user has not yet been told about in the context of this room
+    ...or in the context of this user?  currently all verification is per-user, not per-room.
+    ...this should be good enough.
+
+  - so track whether we have warned the user or not about unverified devices - blocked, unverified, verified, unverified_warned.
+    throw an error when trying to encrypt if there are pure unverified devices there
+    app will have to search for the devices which are pure unverified to warn about them - have to do this from MembersList anyway?
+      - or megolm could warn which devices are causing the problems.
+
+Why do we wait to establish outbound sessions?  It just makes a horrible pause when we first try to send a message... but could otherwise unnecessarily consume resources?

examples/browser/browserTest.js

@@ -1,7 +1,6 @@
-"use strict";
 console.log("Loading browser sdk");
 
-var client = matrixcs.createClient("http://matrix.org");
+var client = matrixcs.createClient("https://matrix.org");
 client.publicRooms(function (err, data) {
     if (err) {
 	   console.error("err %s", JSON.stringify(err));

examples/browser/index.html

@@ -1,6 +1,8 @@
-<html>
+<html lang="en">
 <head>
 <title>Test</title>
+<meta charset="utf-8"/>
+<link rel="icon" href="data:,">
 <script src="lib/matrix.js"></script>
 <script src="browserTest.js"></script>
 </head>

examples/browser/lib/matrix.js

@@ -1 +1 @@
-../../../dist/browser-matrix-dev.js
+../../../dist/browser-matrix.js

examples/crypto-browser/lib/.gitignore

@@ -0,0 +1,2 @@
+olm.js
+olm.wasm

examples/crypto-browser/lib/matrix.js

@@ -0,0 +1 @@
+../../../dist/browser-matrix.js

examples/crypto-browser/olm-device-export-import.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>Test Crypto in Browser</title>
+    <script src="lib/olm.js"></script>
+    <script src="lib/matrix.js"></script>
+</head>
+<body>
+    <h1>Testing export/import of Olm devices in the browser</h1>
+    <ul>
+        <li>
+            Make sure you built the current version of the Matrix JS SDK
+            (<code>yarn build</code>)
+        </li>
+        <li>
+            copy <code>olm.js</code> and <code>olm.wasm</code>
+            from a recent release of Olm (was tested with version 3.1.4)
+            in directory <code>lib/</code>
+        </li>
+        <li>start a local Matrix homeserver (on port 8008, or change the port in the code)</li>
+        <li>Serve this HTML file (e.g. <code>python3 -m http.server</code>) and go to it through your browser</li>
+        <li>
+            in the JS console, do:
+            <pre>
+aliceMatrixClient = await newMatrixClient("alice-"+randomHex());
+await aliceMatrixClient.exportDevice();
+await aliceMatrixClient.getAccessToken();
+            </pre>
+        </li>
+        <li>
+            copy the result of <code>exportDevice</code> and <code>getAccessToken</code> somewhere
+            (<strong>not</strong> in a JS variable as it will be destroyed when you refresh the page)
+        </li>
+        <li><strong>refresh the page (F5)</strong> to make sure the client is destroyed</li>
+        <li>
+            Do the following, replacing <code>ALICE_ID</code>
+            with the user ID of Alice (you can find it in the exported data)
+            <pre>
+bobMatrixClient = await newMatrixClient("bob-"+randomHex());
+roomId = await bobMatrixClient.createEncryptedRoom([ALICE_ID]);
+await bobMatrixClient.sendTextMessage('Hi Alice!', roomId);
+            </pre>
+        </li>
+        <li>Again, <strong>refresh the page (F5)</strong>. You may want to clear your console as well.</li>
+        <li>
+            Now do the following, using the exported data and the access token you saved previously:
+            <pre>
+aliceMatrixClient = await importMatrixClient(EXPORTED_DATA, ACCESS_TOKEN);
+            </pre>
+        </li>
+        <li>You should see the message sent by Bob printed in the console.</li>
+    </ul>
+
+    <script src="olm-device-export-import.js"></script>
+</body>
+</html>

examples/crypto-browser/olm-device-export-import.js

@@ -0,0 +1,122 @@
+if (!Olm) {
+    console.error(
+        "global.Olm does not seem to be present."
+        + " Did you forget to add olm in the lib/ directory?"
+    );
+}
+
+const BASE_URL = 'http://localhost:8008';
+const ROOM_CRYPTO_CONFIG = { algorithm: 'm.megolm.v1.aes-sha2' };
+const PASSWORD = 'password';
+
+// useful to create new usernames
+window.randomHex = () => Math.floor(Math.random() * (10**6)).toString(16);
+
+window.newMatrixClient = async function (username) {
+    const registrationClient = matrixcs.createClient(BASE_URL);
+
+    const userRegisterResult = await registrationClient.register(
+      username,
+      PASSWORD,
+      null,
+      { type: 'm.login.dummy' }
+    );
+  
+    const matrixClient = matrixcs.createClient({
+      baseUrl: BASE_URL,
+      userId: userRegisterResult.user_id,
+      accessToken: userRegisterResult.access_token,
+      deviceId: userRegisterResult.device_id,
+      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+      cryptoStore: new matrixcs.MemoryCryptoStore(),
+    });
+
+    extendMatrixClient(matrixClient);
+
+    await matrixClient.initCrypto();
+    await matrixClient.startClient();
+    return matrixClient;
+}
+
+window.importMatrixClient = async function (exportedDevice, accessToken) {
+    const matrixClient = matrixcs.createClient({
+      baseUrl: BASE_URL,
+      deviceToImport: exportedDevice,
+      accessToken,
+      sessionStore: new matrixcs.WebStorageSessionStore(window.localStorage),
+      cryptoStore: new matrixcs.MemoryCryptoStore(),
+    });
+
+    extendMatrixClient(matrixClient);
+
+    await matrixClient.initCrypto();
+    await matrixClient.startClient();
+    return matrixClient;
+}
+
+function extendMatrixClient(matrixClient) {
+    // automatic join
+    matrixClient.on('RoomMember.membership', async (event, member) => {
+        if (member.membership === 'invite' && member.userId === matrixClient.getUserId()) {
+            await matrixClient.joinRoom(member.roomId);
+            // setting up of room encryption seems to be triggered automatically
+            // but if we don't wait for it the first messages we send are unencrypted
+            await matrixClient.setRoomEncryption(member.roomId, { algorithm: 'm.megolm.v1.aes-sha2' })
+        }
+    });
+
+    matrixClient.onDecryptedMessage = message => {
+        console.log('Got encrypted message: ', message);
+    }
+
+    matrixClient.on('Event.decrypted', (event) => {
+        if (event.getType() === 'm.room.message'){
+            matrixClient.onDecryptedMessage(event.getContent().body);
+        } else {
+            console.log('decrypted an event of type', event.getType());
+            console.log(event);
+        }
+    });
+  
+    matrixClient.createEncryptedRoom = async function(usersToInvite) {
+        const {
+          room_id: roomId,
+        } = await this.createRoom({
+          visibility: 'private',
+          invite: usersToInvite,
+        });
+
+        // matrixClient.setRoomEncryption() only updates local state
+        // but does not send anything to the server
+        // (see https://github.com/matrix-org/matrix-js-sdk/issues/905)
+        // so we do it ourselves with 'sendStateEvent'
+        await this.sendStateEvent(
+          roomId, 'm.room.encryption', ROOM_CRYPTO_CONFIG,
+        );
+        await this.setRoomEncryption(
+          roomId, ROOM_CRYPTO_CONFIG,
+        );
+
+        // Marking all devices as verified
+        let room = this.getRoom(roomId);
+        let members = (await room.getEncryptionTargetMembers()).map(x => x["userId"])
+        let memberkeys = await this.downloadKeys(members);
+        for (const userId in memberkeys) {
+          for (const deviceId in memberkeys[userId]) {
+            await this.setDeviceVerified(userId, deviceId);
+          }
+        }
+
+        return roomId;
+    }
+
+    matrixClient.sendTextMessage = async function(message, roomId) {
+        return matrixClient.sendMessage(
+            roomId,
+            {
+                body: message,
+                msgtype: 'm.text',
+            }
+        )
+    }
+}

examples/node/app.js

@@ -1,5 +1,3 @@
-"use strict";
-
 var myUserId = "@example:localhost";
 var myAccessToken = "QGV4YW1wbGU6bG9jYWxob3N0.qPEvLuYfNBjxikiCjP";
 var sdk = require("matrix-js-sdk");
@@ -56,7 +54,7 @@ rl.on('line', function(line) {
                 }
             }
             if (notSentEvent) {
-                matrixClient.resendEvent(notSentEvent, viewingRoom).done(function() {
+                matrixClient.resendEvent(notSentEvent, viewingRoom).then(function() {
                     printMessages();
                     rl.prompt();
                 }, function(err) {
@@ -70,7 +68,7 @@ rl.on('line', function(line) {
         }
         else if (line.indexOf("/more ") === 0) {
             var amount = parseInt(line.split(" ")[1]) || 20;
-            matrixClient.scrollback(viewingRoom, amount).done(function(room) {
+            matrixClient.scrollback(viewingRoom, amount).then(function(room) {
                 printMessages();
                 rl.prompt();
             }, function(err) {
@@ -79,7 +77,7 @@ rl.on('line', function(line) {
         }
         else if (line.indexOf("/invite ") === 0) {
             var userId = line.split(" ")[1].trim();
-            matrixClient.invite(viewingRoom.roomId, userId).done(function() {
+            matrixClient.invite(viewingRoom.roomId, userId).then(function() {
                 printMessages();
                 rl.prompt();
             }, function(err) {
@@ -92,7 +90,7 @@ rl.on('line', function(line) {
             matrixClient.uploadContent({
                 stream: stream,
                 name: filename
-            }).done(function(url) {
+            }).then(function(url) {
                 var content = {
                     msgtype: "m.file",
                     body: filename,
@@ -116,7 +114,7 @@ rl.on('line', function(line) {
             viewingRoom = roomList[roomIndex];
             if (viewingRoom.getMember(myUserId).membership === "invite") {
                 // join the room first
-                matrixClient.joinRoom(viewingRoom.roomId).done(function(room) {
+                matrixClient.joinRoom(viewingRoom.roomId).then(function(room) {
                     setRoomList();
                     viewingRoom = room;
                     printMessages();
@@ -128,18 +126,22 @@ rl.on('line', function(line) {
             else {
                 printMessages();
             }
-        } 
+        }
     }
     rl.prompt();
 });
 // ==== END User input
 
 // show the room list after syncing.
-matrixClient.on("syncComplete", function() {
-    setRoomList();
-    printRoomList();
-    printHelp();
-    rl.prompt();
+matrixClient.on("sync", function(state, prevState, data) {
+    switch (state) {
+        case "PREPARED":
+          setRoomList();
+          printRoomList();
+          printHelp();
+          rl.prompt();
+        break;
+   }
 });
 
 matrixClient.on("Room", function() {
@@ -198,9 +200,9 @@ function printRoomList() {
             dateStr = new Date(msg.getTs()).toISOString().replace(
                 /T/, ' ').replace(/\..+/, '');
         }
-        var me = roomList[i].getMember(myUserId);
-        if (me) {
-            fmt = fmts[me.membership];
+        var myMembership = roomList[i].getMyMembership();
+        if (myMembership) {
+            fmt = fmts[myMembership];
         }
         var roomName = fixWidth(roomList[i].name, 25);
         print(
@@ -277,8 +279,8 @@ function printMemberList(room) {
             member.membership + new Array(10 - member.membership.length).join(" ")
         );
         print(
-            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"), 
-            membershipWithPadding, member.name, 
+            "%s"+fmt(" :: ")+"%s"+fmt(" (")+"%s"+fmt(")"),
+            membershipWithPadding, member.name,
             (member.userId === myUserId ? "Me" : member.userId),
             fmt
         );
@@ -286,26 +288,27 @@ function printMemberList(room) {
 }
 
 function printRoomInfo(room) {
-    var eventDict = room.currentState.events;
+    var eventMap = room.currentState.events;
     var eTypeHeader = "    Event Type(state_key)    ";
     var sendHeader = "        Sender        ";
     // pad content to 100
     var restCount = (
-        100 - "Content".length - " | ".length - " | ".length - 
+        100 - "Content".length - " | ".length - " | ".length -
         eTypeHeader.length - sendHeader.length
     );
     var padSide = new Array(Math.floor(restCount/2)).join(" ");
     var contentHeader = padSide + "Content" + padSide;
     print(eTypeHeader+sendHeader+contentHeader);
     print(new Array(100).join("-"));
-    Object.keys(eventDict).forEach(function(eventType) {
+    eventMap.keys().forEach(function(eventType) {
         if (eventType === "m.room.member") { return; } // use /members instead.
-        Object.keys(eventDict[eventType]).forEach(function(stateKey) {
+        var eventEventMap = eventMap.get(eventType);
+        eventEventMap.keys().forEach(function(stateKey) {
             var typeAndKey = eventType + (
                 stateKey.length > 0 ? "("+stateKey+")" : ""
             );
             var typeStr = fixWidth(typeAndKey, eTypeHeader.length);
-            var event = eventDict[eventType][stateKey];
+            var event = eventEventMap.get(stateKey);
             var sendStr = fixWidth(event.getSender(), sendHeader.length);
             var contentStr = fixWidth(
                 JSON.stringify(event.getContent()), contentHeader.length
@@ -338,7 +341,7 @@ function printLine(event) {
 
     var maxNameWidth = 15;
     if (name.length > maxNameWidth) {
-        name = name.substr(0, maxNameWidth-1) + "\u2026";
+        name = name.slice(0, maxNameWidth-1) + "\u2026";
     }
 
     if (event.getType() === "m.room.message") {
@@ -395,7 +398,7 @@ function print(str, formatter) {
 
 function fixWidth(str, len) {
     if (str.length > len) {
-        return str.substr(0, len-2) + "\u2026";
+        return str.substring(0, len-2) + "\u2026";
     }
     else if (str.length < len) {
         return str + new Array(len - str.length).join(" ");

examples/voip/browserTest.js

@@ -1,17 +1,17 @@
-"use strict";
 console.log("Loading browser sdk");
-var BASE_URL = "https://matrix.org";
-var TOKEN = "accesstokengoeshere";
-var USER_ID = "@username:localhost";
-var ROOM_ID = "!room:id";
+const BASE_URL = "https://matrix.org";
+const TOKEN = "accesstokengoeshere";
+const USER_ID = "@username:localhost";
+const ROOM_ID = "!room:id";
+const DEVICE_ID = "some_device_id";
 
-
-var client = matrixcs.createClient({
+const client = matrixcs.createClient({
     baseUrl: BASE_URL,
     accessToken: TOKEN,
-    userId: USER_ID
+    userId: USER_ID,
+    deviceId: DEVICE_ID
 });
-var call;
+let call;
 
 function disableButtons(place, answer, hangup) {
     document.getElementById("hangup").disabled = hangup;
@@ -20,7 +20,7 @@ function disableButtons(place, answer, hangup) {
 }
 
 function addListeners(call) {
-    var lastError = "";
+    let lastError = "";
     call.on("hangup", function() {
         disableButtons(false, true, true);
         document.getElementById("result").innerHTML = (
@@ -32,6 +32,23 @@ function addListeners(call) {
         call.hangup();
         disableButtons(false, true, true);
     });
+    call.on("feeds_changed", function(feeds) {
+        const localFeed = feeds.find((feed) => feed.isLocal());
+        const remoteFeed = feeds.find((feed) => !feed.isLocal());
+
+        const remoteElement = document.getElementById("remote");
+        const localElement = document.getElementById("local");
+
+        if (remoteFeed) {
+            remoteElement.srcObject = remoteFeed.stream;
+            remoteElement.play();
+        }
+        if (localFeed) {
+            localElement.muted = true;
+            localElement.srcObject = localFeed.stream;
+            localElement.play();
+        }
+    });
 }
 
 window.onload = function() {
@@ -44,7 +61,15 @@ window.onload = function() {
     disableButtons(true, true, true);
 };
 
-client.on("syncComplete", function () {
+client.on("sync", function(state, prevState, data) {
+    switch (state) {
+        case "PREPARED":
+          syncComplete();
+        break;
+   }
+});
+
+function syncComplete() {
     document.getElementById("result").innerHTML = "<p>Ready for calls.</p>";
     disableButtons(false, true, true);
 
@@ -55,10 +80,7 @@ client.on("syncComplete", function () {
         );
         console.log("Call => %s", call);
         addListeners(call);
-        call.placeVideoCall(
-            document.getElementById("remote"),
-            document.getElementById("local")
-        );
+        call.placeVideoCall();
         document.getElementById("result").innerHTML = "<p>Placed call.</p>";
         disableButtons(true, true, false);
     };
@@ -85,5 +107,5 @@ client.on("syncComplete", function () {
         call = c;
         addListeners(call);
     });
-});
+}
 client.startClient();

examples/voip/index.html

@@ -1,26 +1,34 @@
 <html>
+
 <head>
-<title>VoIP Test</title>
-<script src="lib/matrix.js"></script>
-<script src="browserTest.js"></script>
+    <title>VoIP Test</title>
+    <script src="lib/matrix.js"></script>
+    <script src="browserTest.js"></script>
 </head>
+
 <body>
-	You can place and receive calls with this example. Make sure to edit the
+    You can place and receive calls with this example. Make sure to edit the
     constants in <code>browserTest.js</code> first.
     <div id="config"></div>
     <div id="result"></div>
     <button id="call">Place Call</button>
     <button id="answer">Answer Call</button>
     <button id="hangup">Hangup Call</button>
-    <div id="videoBackground">
-        <div id="videoContainer">
-            <video id="remote"></video>
-        </div>
-    </div>
-    <div id="videoBackground">
-        <div id="videoContainer">
-            <video id="local"></video>
-        </div>
+    <div id="videoBackground" class="video-background">
+        <video class="video-element" id="local"></video>
+        <video class="video-element" id="remote"></video>
     </div>
 </body>
+
 </html>
+
+<style>
+    .video-background {
+        height: 500px;
+        margin: 10px;
+    }
+
+    .video-element {
+        height: 100%;
+    }
+</style>

examples/voip/lib/matrix.js

@@ -1 +1 @@
-../../../dist/browser-matrix-dev.js
+../../../dist/browser-matrix.js

git-hooks/pre-commit

@@ -21,4 +21,4 @@ export PATH="$rootdir/node_modules/.bin:$PATH"
 
 # now run our checks
 cd "$tmpdir"
-npm run lint
+yarn lint

index.js

@@ -1,6 +0,0 @@
-var matrixcs = require("./lib/matrix");
-matrixcs.request(require("request"));
-module.exports = matrixcs;
-
-var utils = require("./lib/utils");
-utils.runPolyfills();

jenkins.sh

@@ -1,31 +0,0 @@
-#!/bin/bash -l
-
-export NVM_DIR="/home/jenkins/.nvm"
-[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
-nvm use 0.10
-npm install
-
-RC=0
-
-function fail {
-    echo $@ >&2
-    RC=1
-}
-
-npm test || fail "npm test finished with return code $?"
-
-jshint --reporter=checkstyle -c .jshint lib spec > jshint.xml ||
-    fail "jshint finished with return code $?"
-
-gjslint --unix_mode --disable 0131,0211,0200,0222,0212 \
-        --max_line_length 90 \
-        -r lib/ -r spec/ > gjslint.log ||
-    fail "gjslint finished with return code $?"
-
-# delete the old tarball, if it exists
-rm -f matrix-js-sdk-*.tgz
-
-npm pack ||
-    fail "npm pack finished with return code $?"
-
-exit $RC

jsdoc.json

@@ -0,0 +1,30 @@
+{
+  "tags": {
+    "allowUnknownTags": true
+  },
+  "plugins": [
+    "node_modules/better-docs/category",
+    "node_modules/better-docs/typescript"
+  ],
+  "source": {
+    "include": [
+      "src"
+    ],
+    "includePattern": ".(ts|js)$"
+  },
+  "opts": {
+    "encoding": "utf8",
+    "destination": ".jsdoc",
+    "readme": "README.md",
+    "recurse": true,
+    "verbose": true,
+    "template": "node_modules/docdash"
+  },
+  "docdash": {
+    "static": true,
+    "private": false,
+    "search": true,
+    "collapse": true,
+    "typedefs": true
+  }
+}

lib/content-repo.js

@@ -1,105 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-/**
- * @module content-repo
- */
-var utils = require("./utils");
-
-/** Content Repo utility functions */
-module.exports = {
-    /**
-     * Get the HTTP URL for an MXC URI.
-     * @param {string} baseUrl The base homeserver url which has a content repo.
-     * @param {string} mxc The mxc:// URI.
-     * @param {Number} width The desired width of the thumbnail.
-     * @param {Number} height The desired height of the thumbnail.
-     * @param {string} resizeMethod The thumbnail resize method to use, either
-     * "crop" or "scale".
-     * @param {Boolean} allowDirectLinks If true, return any non-mxc URLs
-     * directly. Fetching such URLs will leak information about the user to
-     * anyone they share a room with. If false, will return the emptry string
-     * for such URLs.
-     * @return {string} The complete URL to the content.
-     */
-    getHttpUriForMxc: function(baseUrl, mxc, width, height,
-                               resizeMethod, allowDirectLinks) {
-        if (typeof mxc !== "string" || !mxc) {
-            return '';
-        }
-        if (mxc.indexOf("mxc://") !== 0) {
-            if (allowDirectLinks) {
-                return mxc;
-            } else {
-                return '';
-            }
-        }
-        var serverAndMediaId = mxc.slice(6); // strips mxc://
-        var prefix = "/_matrix/media/v1/download/";
-        var params = {};
-
-        if (width) {
-            params.width = width;
-        }
-        if (height) {
-            params.height = height;
-        }
-        if (resizeMethod) {
-            params.method = resizeMethod;
-        }
-        if (utils.keys(params).length > 0) {
-            // these are thumbnailing params so they probably want the
-            // thumbnailing API...
-            prefix = "/_matrix/media/v1/thumbnail/";
-        }
-
-        var fragmentOffset = serverAndMediaId.indexOf("#"),
-            fragment = "";
-        if (fragmentOffset >= 0) {
-            fragment = serverAndMediaId.substr(fragmentOffset);
-            serverAndMediaId = serverAndMediaId.substr(0, fragmentOffset);
-        }
-        return baseUrl + prefix + serverAndMediaId +
-            (utils.keys(params).length === 0 ? "" :
-            ("?" + utils.encodeParams(params))) + fragment;
-    },
-
-    /**
-     * Get an identicon URL from an arbitrary string.
-     * @param {string} baseUrl The base homeserver url which has a content repo.
-     * @param {string} identiconString The string to create an identicon for.
-     * @param {Number} width The desired width of the image in pixels. Default: 96.
-     * @param {Number} height The desired height of the image in pixels. Default: 96.
-     * @return {string} The complete URL to the identicon.
-     */
-    getIdenticonUri: function(baseUrl, identiconString, width, height) {
-        if (!identiconString) {
-            return null;
-        }
-        if (!width) { width = 96; }
-        if (!height) { height = 96; }
-        var params = {
-            width: width,
-            height: height
-        };
-
-        var path = utils.encodeUri("/_matrix/media/v1/identicon/$ident", {
-            $ident: identiconString
-        });
-        return baseUrl + path +
-            (utils.keys(params).length === 0 ? "" :
-                ("?" + utils.encodeParams(params)));
-    }
-};

lib/crypto/OlmDevice.js

@@ -1,694 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * olm.js wrapper
- *
- * @module crypto/OlmDevice
- */
-
-var Olm = require("olm");
-var utils = require("../utils");
-
-/**
- * Manages the olm cryptography functions. Each OlmDevice has a single
- * OlmAccount and a number of OlmSessions.
- *
- * Accounts and sessions are kept pickled in a sessionStore.
- *
- * @constructor
- * @alias module:crypto/OlmDevice
- *
- * @param {Object} sessionStore A store to be used for data in end-to-end
- *    crypto
- *
- * @property {string} deviceCurve25519Key   Curve25519 key for the account
- * @property {string} deviceEd25519Key      Ed25519 key for the account
- */
-function OlmDevice(sessionStore) {
-    this._sessionStore = sessionStore;
-    this._pickleKey = "DEFAULT_KEY";
-
-    var e2eKeys;
-    var account = new Olm.Account();
-    try {
-        _initialise_account(this._sessionStore, this._pickleKey, account);
-        e2eKeys = JSON.parse(account.identity_keys());
-    } finally {
-        account.free();
-    }
-
-    this.deviceCurve25519Key = e2eKeys.curve25519;
-    this.deviceEd25519Key = e2eKeys.ed25519;
-
-    // we don't bother stashing outboundgroupsessions in the sessionstore -
-    // instead we keep them here.
-    this._outboundGroupSessionStore = {};
-}
-
-function _initialise_account(sessionStore, pickleKey, account) {
-    var e2eAccount = sessionStore.getEndToEndAccount();
-    if (e2eAccount !== null) {
-        account.unpickle(pickleKey, e2eAccount);
-        return;
-    }
-
-    account.create();
-    var pickled = account.pickle(pickleKey);
-    sessionStore.storeEndToEndAccount(pickled);
-}
-
-/**
- * @return {array} The version of Olm.
- */
-OlmDevice.getOlmVersion = function() {
-    return Olm.get_library_version();
-};
-
-
-/**
- * extract our OlmAccount from the session store and call the given function
- *
- * @param {function} func
- * @return {object} result of func
- * @private
- */
-OlmDevice.prototype._getAccount = function(func) {
-    var account = new Olm.Account();
-    try {
-        var pickledAccount = this._sessionStore.getEndToEndAccount();
-        account.unpickle(this._pickleKey, pickledAccount);
-        return func(account);
-    } finally {
-        account.free();
-    }
-};
-
-
-/**
- * store our OlmAccount in the session store
- *
- * @param {OlmAccount} account
- * @private
- */
-OlmDevice.prototype._saveAccount = function(account) {
-    var pickledAccount = account.pickle(this._pickleKey);
-    this._sessionStore.storeEndToEndAccount(pickledAccount);
-};
-
-
-/**
- * extract an OlmSession from the session store and call the given function
- *
- * @param {string} deviceKey
- * @param {string} sessionId
- * @param {function} func
- * @return {object} result of func
- * @private
- */
-OlmDevice.prototype._getSession = function(deviceKey, sessionId, func) {
-    var sessions = this._sessionStore.getEndToEndSessions(deviceKey);
-    var pickledSession = sessions[sessionId];
-
-    var session = new Olm.Session();
-    try {
-        session.unpickle(this._pickleKey, pickledSession);
-        return func(session);
-    } finally {
-        session.free();
-    }
-};
-
-
-/**
- * store our OlmSession in the session store
- *
- * @param {string} deviceKey
- * @param {OlmSession} session
- * @private
- */
-OlmDevice.prototype._saveSession = function(deviceKey, session) {
-    var pickledSession = session.pickle(this._pickleKey);
-    this._sessionStore.storeEndToEndSession(
-        deviceKey, session.session_id(), pickledSession
-    );
-};
-
-
-/**
- * get an OlmUtility and call the given function
- *
- * @param {function} func
- * @return {object} result of func
- * @private
- */
-OlmDevice.prototype._getUtility = function(func) {
-    var utility = new Olm.Utility();
-    try {
-        return func(utility);
-    } finally {
-        utility.free();
-    }
-};
-
-
-/**
- * Signs a message with the ed25519 key for this account.
- *
- * @param {string} message  message to be signed
- * @return {string} base64-encoded signature
- */
-OlmDevice.prototype.sign = function(message) {
-    return this._getAccount(function(account) {
-        return account.sign(message);
-    });
-};
-
-/**
- * Get the current (unused, unpublished) one-time keys for this account.
- *
- * @return {object} one time keys; an object with the single property
- * <tt>curve25519</tt>, which is itself an object mapping key id to Curve25519
- * key.
- */
-OlmDevice.prototype.getOneTimeKeys = function() {
-    return this._getAccount(function(account) {
-        return JSON.parse(account.one_time_keys());
-    });
-};
-
-
-/**
- * Get the maximum number of one-time keys we can store.
- *
- * @return {number} number of keys
- */
-OlmDevice.prototype.maxNumberOfOneTimeKeys = function() {
-    return this._getAccount(function(account) {
-        return account.max_number_of_one_time_keys();
-    });
-};
-
-/**
- * Marks all of the one-time keys as published.
- */
-OlmDevice.prototype.markKeysAsPublished = function() {
-    var self = this;
-    this._getAccount(function(account) {
-        account.mark_keys_as_published();
-        self._saveAccount(account);
-    });
-};
-
-/**
- * Generate some new one-time keys
- *
- * @param {number} numKeys number of keys to generate
- */
-OlmDevice.prototype.generateOneTimeKeys = function(numKeys) {
-    var self = this;
-    this._getAccount(function(account) {
-        account.generate_one_time_keys(numKeys);
-        self._saveAccount(account);
-    });
-};
-
-/**
- * Generate a new outbound session
- *
- * The new session will be stored in the sessionStore.
- *
- * @param {string} theirIdentityKey remote user's Curve25519 identity key
- * @param {string} theirOneTimeKey  remote user's one-time Curve25519 key
- * @return {string} sessionId for the outbound session.
- */
-OlmDevice.prototype.createOutboundSession = function(
-    theirIdentityKey, theirOneTimeKey
-) {
-    var self = this;
-    return this._getAccount(function(account) {
-        var session = new Olm.Session();
-        try {
-            session.create_outbound(account, theirIdentityKey, theirOneTimeKey);
-            self._saveSession(theirIdentityKey, session);
-            return session.session_id();
-        } finally {
-            session.free();
-        }
-    });
-};
-
-
-/**
- * Generate a new inbound session, given an incoming message
- *
- * @param {string} theirDeviceIdentityKey remote user's Curve25519 identity key
- * @param {number} message_type  message_type field from the received message (must be 0)
- * @param {string} ciphertext base64-encoded body from the received message
- *
- * @return {{payload: string, session_id: string}} decrypted payload, and
- *     session id of new session
- *
- * @raises {Error} if the received message was not valid (for instance, it
- *     didn't use a valid one-time key).
- */
-OlmDevice.prototype.createInboundSession = function(
-    theirDeviceIdentityKey, message_type, ciphertext
-) {
-    if (message_type !== 0) {
-        throw new Error("Need message_type == 0 to create inbound session");
-    }
-
-    var self = this;
-    return this._getAccount(function(account) {
-        var session = new Olm.Session();
-        try {
-            session.create_inbound_from(account, theirDeviceIdentityKey, ciphertext);
-            account.remove_one_time_keys(session);
-            self._saveAccount(account);
-
-            var payloadString = session.decrypt(message_type, ciphertext);
-
-            self._saveSession(theirDeviceIdentityKey, session);
-
-            return {
-                payload: payloadString,
-                session_id: session.session_id(),
-            };
-        } finally {
-            session.free();
-        }
-    });
-};
-
-
-/**
- * Get a list of known session IDs for the given device
- *
- * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
- *     remote device
- * @return {string[]}  a list of known session ids for the device
- */
-OlmDevice.prototype.getSessionIdsForDevice = function(theirDeviceIdentityKey) {
-    var sessions = this._sessionStore.getEndToEndSessions(
-        theirDeviceIdentityKey
-    );
-    return utils.keys(sessions);
-};
-
-/**
- * Get the right olm session id for encrypting messages to the given identity key
- *
- * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
- *     remote device
- * @return {string?}  session id, or null if no established session
- */
-OlmDevice.prototype.getSessionIdForDevice = function(theirDeviceIdentityKey) {
-    var sessionIds = this.getSessionIdsForDevice(theirDeviceIdentityKey);
-    if (sessionIds.length === 0) {
-        return null;
-    }
-    // Use the session with the lowest ID.
-    sessionIds.sort();
-    return sessionIds[0];
-};
-
-/**
- * Get information on the active Olm sessions for a device.
- * <p>
- * Returns an array, with an entry for each active session. The first entry in
- * the result will be the one used for outgoing messages. Each entry contains
- * the keys 'hasReceivedMessage' (true if the session has received an incoming
- * message and is therefore past the pre-key stage), and 'sessionId'.
- *
- * @param {string} deviceIdentityKey Curve25519 identity key for the device
- * @return {Array.<{sessionId: string, hasReceivedMessage: Boolean}>}
- */
-OlmDevice.prototype.getSessionInfoForDevice = function(deviceIdentityKey) {
-    var sessionIds = this.getSessionIdsForDevice(deviceIdentityKey);
-    sessionIds.sort();
-
-    var info = [];
-
-    function getSessionInfo(session) {
-        return {
-            hasReceivedMessage: session.has_received_message()
-        };
-    }
-
-    for (var i = 0; i < sessionIds.length; i++) {
-        var sessionId = sessionIds[i];
-        var res = this._getSession(deviceIdentityKey, sessionId, getSessionInfo);
-        res.sessionId = sessionId;
-        info.push(res);
-    }
-    return info;
-};
-
-/**
- * Encrypt an outgoing message using an existing session
- *
- * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
- *     remote device
- * @param {string} sessionId  the id of the active session
- * @param {string} payloadString  payload to be encrypted and sent
- *
- * @return {string} ciphertext
- */
-OlmDevice.prototype.encryptMessage = function(
-    theirDeviceIdentityKey, sessionId, payloadString
-) {
-    var self = this;
-
-    return this._getSession(theirDeviceIdentityKey, sessionId, function(session) {
-        var res = session.encrypt(payloadString);
-        self._saveSession(theirDeviceIdentityKey, session);
-        return res;
-    });
-};
-
-/**
- * Decrypt an incoming message using an existing session
- *
- * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
- *     remote device
- * @param {string} sessionId  the id of the active session
- * @param {number} message_type  message_type field from the received message
- * @param {string} ciphertext base64-encoded body from the received message
- *
- * @return {string} decrypted payload.
- */
-OlmDevice.prototype.decryptMessage = function(
-    theirDeviceIdentityKey, sessionId, message_type, ciphertext
-) {
-    var self = this;
-
-    return this._getSession(theirDeviceIdentityKey, sessionId, function(session) {
-        var payloadString = session.decrypt(message_type, ciphertext);
-        self._saveSession(theirDeviceIdentityKey, session);
-
-        return payloadString;
-    });
-};
-
-/**
- * Determine if an incoming messages is a prekey message matching an existing session
- *
- * @param {string} theirDeviceIdentityKey Curve25519 identity key for the
- *     remote device
- * @param {string} sessionId  the id of the active session
- * @param {number} message_type  message_type field from the received message
- * @param {string} ciphertext base64-encoded body from the received message
- *
- * @return {boolean} true if the received message is a prekey message which matches
- *    the given session.
- */
-OlmDevice.prototype.matchesSession = function(
-    theirDeviceIdentityKey, sessionId, message_type, ciphertext
-) {
-    if (message_type !== 0) {
-        return false;
-    }
-
-    return this._getSession(theirDeviceIdentityKey, sessionId, function(session) {
-        return session.matches_inbound(ciphertext);
-    });
-};
-
-
-
-// Outbound group session
-// ======================
-
-/**
- * store an OutboundGroupSession in _outboundGroupSessionStore
- *
- * @param {Olm.OutboundGroupSession} session
- * @private
- */
-OlmDevice.prototype._saveOutboundGroupSession = function(session) {
-    var pickledSession = session.pickle(this._pickleKey);
-    this._outboundGroupSessionStore[session.session_id()] = pickledSession;
-};
-
-
-/**
- * extract an OutboundGroupSession from _outboundGroupSessionStore and call the
- * given function
- *
- * @param {string} sessionId
- * @param {function} func
- * @return {object} result of func
- * @private
- */
-OlmDevice.prototype._getOutboundGroupSession = function(sessionId, func) {
-    var pickled = this._outboundGroupSessionStore[sessionId];
-    if (pickled === null) {
-        throw new Error("Unknown outbound group session " + sessionId);
-    }
-
-    var session = new Olm.OutboundGroupSession();
-    try {
-        session.unpickle(this._pickleKey, pickled);
-        return func(session);
-    } finally {
-        session.free();
-    }
-};
-
-
-/**
- * Generate a new outbound group session
- *
- * @return {string} sessionId for the outbound session.
- */
-OlmDevice.prototype.createOutboundGroupSession = function() {
-    var session = new Olm.OutboundGroupSession();
-    try {
-        session.create();
-        this._saveOutboundGroupSession(session);
-        return session.session_id();
-    } finally {
-        session.free();
-    }
-};
-
-
-/**
- * Encrypt an outgoing message with an outbound group session
- *
- * @param {string} sessionId  the id of the outboundgroupsession
- * @param {string} payloadString  payload to be encrypted and sent
- *
- * @return {string} ciphertext
- */
-OlmDevice.prototype.encryptGroupMessage = function(sessionId, payloadString) {
-    var self = this;
-
-    return this._getOutboundGroupSession(sessionId, function(session) {
-        var res = session.encrypt(payloadString);
-        self._saveOutboundGroupSession(session);
-        return res;
-    });
-};
-
-/**
- * Get the session keys for an outbound group session
- *
- * @param {string} sessionId  the id of the outbound group session
- *
- * @return {{chain_index: number, key: string}} current chain index, and
- *     base64-encoded secret key.
- */
-OlmDevice.prototype.getOutboundGroupSessionKey = function(sessionId) {
-    return this._getOutboundGroupSession(sessionId, function(session) {
-        return {
-            chain_index: session.message_index(),
-            key: session.session_key(),
-        };
-    });
-};
-
-
-// Inbound group session
-// =====================
-
-/**
- * store an InboundGroupSession in the session store
- *
- * @param {string} roomId
- * @param {string} senderCurve25519Key
- * @param {string} sessionId
- * @param {Olm.InboundGroupSession} session
- * @param {object} keysClaimed Other keys the sender claims.
- * @private
- */
-OlmDevice.prototype._saveInboundGroupSession = function(
-    roomId, senderCurve25519Key, sessionId, session, keysClaimed
-) {
-    var r = {
-        room_id: roomId,
-        session: session.pickle(this._pickleKey),
-        keysClaimed: keysClaimed,
-    };
-
-    this._sessionStore.storeEndToEndInboundGroupSession(
-        senderCurve25519Key, sessionId, JSON.stringify(r)
-    );
-};
-
-/**
- * extract an InboundGroupSession from the session store and call the given function
- *
- * @param {string} roomId
- * @param {string} senderKey
- * @param {string} sessionId
- * @param {function(Olm.InboundGroupSession, Object<string, string>): T} func
- *   function to call. Second argument is the map of keys claimed by the session.
- *
- * @return {null} the sessionId is unknown
- *
- * @return {T} result of func
- *
- * @private
- * @template {T}
- */
-OlmDevice.prototype._getInboundGroupSession = function(
-    roomId, senderKey, sessionId, func
-) {
-    var r = this._sessionStore.getEndToEndInboundGroupSession(
-        senderKey, sessionId
-    );
-
-    if (r === null) {
-        return null;
-    }
-
-    r = JSON.parse(r);
-
-    // check that the room id matches the original one for the session. This stops
-    // the HS pretending a message was targeting a different room.
-    if (roomId !== r.room_id) {
-        throw new Error(
-            "Mismatched room_id for inbound group session (expected " + r.room_id +
-                ", was " + roomId + ")"
-        );
-    }
-
-    var session = new Olm.InboundGroupSession();
-    try {
-        session.unpickle(this._pickleKey, r.session);
-        return func(session, r.keysClaimed || {});
-    } finally {
-        session.free();
-    }
-};
-
-/**
- * Add an inbound group session to the session store
- *
- * @param {string} roomId     room in which this session will be used
- * @param {string} senderKey  base64-encoded curve25519 key of the sender
- * @param {string} sessionId  session identifier
- * @param {string} sessionKey base64-encoded secret key
- * @param {Object<string, string>} keysClaimed Other keys the sender claims.
- */
-OlmDevice.prototype.addInboundGroupSession = function(
-    roomId, senderKey, sessionId, sessionKey, keysClaimed
-) {
-    var self = this;
-    var session = new Olm.InboundGroupSession();
-    try {
-        session.create(sessionKey);
-        if (sessionId != session.session_id()) {
-            throw new Error(
-                "Mismatched group session ID from senderKey: " + senderKey
-            );
-        }
-        self._saveInboundGroupSession(
-            roomId, senderKey, sessionId, session, keysClaimed
-        );
-    } finally {
-        session.free();
-    }
-};
-
-/**
- * Decrypt a received message with an inbound group session
- *
- * @param {string} roomId    room in which the message was received
- * @param {string} senderKey base64-encoded curve25519 key of the sender
- * @param {string} sessionId session identifier
- * @param {string} body      base64-encoded body of the encrypted message
- *
- * @return {null} the sessionId is unknown
- *
- * @return {{result: string, keysProved: Object<string, string>, keysClaimed:
- *    Object<string, string>}} result
- */
-OlmDevice.prototype.decryptGroupMessage = function(
-    roomId, senderKey, sessionId, body
-) {
-    var self = this;
-
-    function decrypt(session, keysClaimed) {
-        var res = session.decrypt(body);
-
-        // the sender must have had the senderKey to persuade us to save the
-        // session.
-        var keysProved = {curve25519: senderKey};
-
-        self._saveInboundGroupSession(
-            roomId, senderKey, sessionId, session, keysClaimed
-        );
-        return {
-            result: res,
-            keysClaimed: keysClaimed,
-            keysProved: keysProved,
-        };
-    }
-
-    return this._getInboundGroupSession(
-        roomId, senderKey, sessionId, decrypt
-    );
-};
-
-
-// Utilities
-// =========
-
-/**
- * Verify an ed25519 signature.
- *
- * @param {string} key ed25519 key
- * @param {string} message message which was signed
- * @param {string} signature base64-encoded signature to be checked
- *
- * @raises {Error} if there is a problem with the verification. If the key was
- * too small then the message will be "OLM.INVALID_BASE64". If the signature
- * was invalid then the message will be "OLM.BAD_MESSAGE_MAC".
- */
-OlmDevice.prototype.verifySignature = function(
-    key, message, signature
-) {
-    this._getUtility(function(util) {
-        util.ed25519_verify(key, message, signature);
-    });
-};
-
-/** */
-module.exports = OlmDevice;

lib/crypto/algorithms/base.js

@@ -1,166 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * Internal module. Defines the base classes of the encryption implementations
- *
- * @module crypto/algorithms/base
- */
-var utils = require("../../utils");
-
-/**
- * map of registered encryption algorithm classes. A map from string to {@link
- * module:crypto/algorithms/base.EncryptionAlgorithm|EncryptionAlgorithm} class
- *
- * @type {Object.<string, function(new: module:crypto/algorithms/base.EncryptionAlgorithm)>}
- */
-module.exports.ENCRYPTION_CLASSES = {};
-
-/**
- * map of registered encryption algorithm classes. Map from string to {@link
- * module:crypto/algorithms/base.DecryptionAlgorithm|DecryptionAlgorithm} class
- *
- * @type {Object.<string, function(new: module:crypto/algorithms/base.DecryptionAlgorithm)>}
- */
-module.exports.DECRYPTION_CLASSES = {};
-
-/**
- * base type for encryption implementations
- *
- * @constructor
- * @alias module:crypto/algorithms/base.EncryptionAlgorithm
- *
- * @param {object} params parameters
- * @param {string} params.deviceId The identifier for this device.
- * @param {module:crypto} params.crypto crypto core
- * @param {module:crypto/OlmDevice} params.olmDevice olm.js wrapper
- * @param {module:base-apis~MatrixBaseApis} baseApis base matrix api interface
- * @param {string} params.roomId  The ID of the room we will be sending to
- */
-var EncryptionAlgorithm = function(params) {
-    this._deviceId = params.deviceId;
-    this._crypto = params.crypto;
-    this._olmDevice = params.olmDevice;
-    this._baseApis = params.baseApis;
-    this._roomId = params.roomId;
-};
-/** */
-module.exports.EncryptionAlgorithm = EncryptionAlgorithm;
-
-/**
- * Encrypt a message event
- *
- * @method module:crypto/algorithms/base.EncryptionAlgorithm#encryptMessage
- * @abstract
- *
- * @param {module:models/room} room
- * @param {string} eventType
- * @param {object} plaintext event content
- *
- * @return {module:client.Promise} Promise which resolves to the new event body
- */
-
-/**
- * Called when the membership of a member of the room changes.
- *
- * @param {module:models/event.MatrixEvent} event  event causing the change
- * @param {module:models/room-member} member  user whose membership changed
- * @param {string=} oldMembership  previous membership
- */
-EncryptionAlgorithm.prototype.onRoomMembership = function(
-    event, member, oldMembership
-) {};
-
-/**
- * Called when a new device announces itself in the room
- *
- * @param {string} userId    owner of the device
- * @param {string} deviceId  deviceId of the device
- */
-EncryptionAlgorithm.prototype.onNewDevice = function(userId, deviceId) {};
-
-
-/**
- * base type for decryption implementations
- *
- * @constructor
- * @alias module:crypto/algorithms/base.DecryptionAlgorithm
- *
- * @param {object} params parameters
- * @param {module:crypto/OlmDevice} params.olmDevice olm.js wrapper
- */
-var DecryptionAlgorithm = function(params) {
-    this._olmDevice = params.olmDevice;
-};
-/** */
-module.exports.DecryptionAlgorithm = DecryptionAlgorithm;
-
-/**
- * Decrypt an event
- *
- * @method module:crypto/algorithms/base.DecryptionAlgorithm#decryptEvent
- * @abstract
- *
- * @param {object} event raw event
- *
- * @return {null} if the event referred to an unknown megolm session
- * @return {module:crypto.DecryptionResult} decryption result
- *
- * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
- *   problem decrypting the event
- */
-
-/**
- * Handle a key event
- *
- * @method module:crypto/algorithms/base.DecryptionAlgorithm#onRoomKeyEvent
- *
- * @param {module:models/event.MatrixEvent} event key event
- */
-DecryptionAlgorithm.prototype.onRoomKeyEvent = function(params) {
-    // ignore by default
-};
-
-/**
- * Exception thrown when decryption fails
- *
- * @constructor
- * @param {string} msg message describing the problem
- * @extends Error
- */
-module.exports.DecryptionError = function(msg) {
-    this.message = msg;
-};
-utils.inherits(module.exports.DecryptionError, Error);
-
-/**
- * Registers an encryption/decryption class for a particular algorithm
- *
- * @param {string} algorithm algorithm tag to register for
- *
- * @param {class} encryptor {@link
- *     module:crypto/algorithms/base.EncryptionAlgorithm|EncryptionAlgorithm}
- *     implementation
- *
- * @param {class} decryptor {@link
- *     module:crypto/algorithms/base.DecryptionAlgorithm|DecryptionAlgorithm}
- *     implementation
- */
-module.exports.registerAlgorithm = function(algorithm, encryptor, decryptor) {
-    module.exports.ENCRYPTION_CLASSES[algorithm] = encryptor;
-    module.exports.DECRYPTION_CLASSES[algorithm] = decryptor;
-};

lib/crypto/algorithms/megolm.js

@@ -1,458 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * Defines m.olm encryption/decryption
- *
- * @module crypto/algorithms/megolm
- */
-
-var q = require("q");
-
-var utils = require("../../utils");
-var olmlib = require("../olmlib");
-var base = require("./base");
-
-/**
- * Megolm encryption implementation
- *
- * @constructor
- * @extends {module:crypto/algorithms/base.EncryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/base.EncryptionAlgorithm}
- */
-function MegolmEncryption(params) {
-    base.EncryptionAlgorithm.call(this, params);
-    this._prepPromise = null;
-    this._outboundSessionId = null;
-    this._discardNewSession = false;
-
-    // devices which have joined since we last sent a message.
-    // userId -> {deviceId -> true}, or
-    // userId -> true
-    this._devicesPendingKeyShare = {};
-    this._sharePromise = null;
-}
-utils.inherits(MegolmEncryption, base.EncryptionAlgorithm);
-
-/**
- * @private
- *
- * @param {module:models/room} room
- *
- * @return {module:client.Promise} Promise which resolves to the megolm
- *   sessionId when setup is complete.
- */
-MegolmEncryption.prototype._ensureOutboundSession = function(room) {
-    var self = this;
-
-    if (this._prepPromise) {
-        // prep already in progress
-        return this._prepPromise;
-    }
-
-    var sessionId = this._outboundSessionId;
-
-    // need to make a brand new session?
-    if (!sessionId) {
-        this._prepPromise = this._prepareNewSession(room).
-            finally(function() {
-                self._prepPromise = null;
-            });
-        return this._prepPromise;
-    }
-
-    if (this._sharePromise) {
-        // key share already in progress
-        return this._sharePromise;
-    }
-
-    // prep already done, but check for new devices
-    var shareMap = this._devicesPendingKeyShare;
-    this._devicesPendingKeyShare = {};
-
-    // check each user is (still) a member of the room
-    for (var userId in shareMap) {
-        if (!shareMap.hasOwnProperty(userId)) {
-            continue;
-        }
-
-        // XXX what about rooms where invitees can see the content?
-        var member = room.getMember(userId);
-        if (member.membership !== "join") {
-            delete shareMap[userId];
-        }
-    }
-
-    this._sharePromise = this._shareKeyWithDevices(
-        sessionId, shareMap
-    ).finally(function() {
-        self._sharePromise = null;
-    }).then(function() {
-        return sessionId;
-    });
-
-    return this._sharePromise;
-};
-
-/**
- * @private
- *
- * @param {module:models/room} room
- *
- * @return {module:client.Promise} Promise which resolves to the megolm
- *   sessionId when setup is complete.
- */
-MegolmEncryption.prototype._prepareNewSession = function(room) {
-    var session_id = this._olmDevice.createOutboundGroupSession();
-    var key = this._olmDevice.getOutboundGroupSessionKey(session_id);
-
-    this._olmDevice.addInboundGroupSession(
-        this._roomId, this._olmDevice.deviceCurve25519Key, session_id,
-        key.key, {ed25519: this._olmDevice.deviceEd25519Key}
-    );
-
-    // we're going to share the key with all current members of the room,
-    // so we can reset this.
-    this._devicesPendingKeyShare = {};
-
-    var roomMembers = utils.map(room.getJoinedMembers(), function(u) {
-        return u.userId;
-    });
-
-    var shareMap = {};
-    for (var i = 0; i < roomMembers.length; i++) {
-        var userId = roomMembers[i];
-        shareMap[userId] = true;
-    }
-
-    var self = this;
-
-    // TODO: we need to give the user a chance to block any devices or users
-    // before we send them the keys; it's too late to download them here.
-    return this._crypto.downloadKeys(
-        roomMembers, false
-    ).then(function(res) {
-        return self._shareKeyWithDevices(session_id, shareMap);
-    }).then(function() {
-        if (self._discardNewSession) {
-            // we've had cause to reset the session_id since starting this process.
-            // we'll use the current session for any currently pending events, but
-            // don't save it as the current _outboundSessionId, so that new events
-            // will use a new session.
-            console.log("Session generation complete, but discarding");
-        } else {
-            self._outboundSessionId = session_id;
-        }
-        return session_id;
-    }).finally(function() {
-        self._discardNewSession = false;
-    });
-};
-
-/**
- * @private
- *
- * @param {string} session_id
- *
- * @param {Object<string, Object<string, boolean>|boolean>} shareMap
- *    Map from userid to either: true (meaning this is a new user in the room,
- *    so all of his devices need the keys); or a map from deviceid to true
- *    (meaning this user has one or more new devices, which need the keys).
- *
- * @return {module:client.Promise} Promise which resolves once the key sharing
- *     message has been sent.
- */
-MegolmEncryption.prototype._shareKeyWithDevices = function(session_id, shareMap) {
-    var self = this;
-
-    var key = this._olmDevice.getOutboundGroupSessionKey(session_id);
-    var payload = {
-        type: "m.room_key",
-        content: {
-            algorithm: olmlib.MEGOLM_ALGORITHM,
-            room_id: this._roomId,
-            session_id: session_id,
-            session_key: key.key,
-            chain_index: key.chain_index,
-        }
-    };
-
-    // we downloaded the user's device list when they joined the room, or when
-    // the new device announced itself, so there is no need to do so now.
-
-    return self._crypto.ensureOlmSessionsForUsers(
-        utils.keys(shareMap)
-    ).then(function(devicemap) {
-        var contentMap = {};
-        var haveTargets = false;
-
-        for (var userId in devicemap) {
-            if (!devicemap.hasOwnProperty(userId)) {
-                continue;
-            }
-
-            var devicesToShareWith = shareMap[userId];
-            var sessionResults = devicemap[userId];
-
-            for (var deviceId in sessionResults) {
-                if (!sessionResults.hasOwnProperty(deviceId)) {
-                    continue;
-                }
-
-                if (devicesToShareWith === true) {
-                    // all devices
-                } else if (!devicesToShareWith[deviceId]) {
-                    // not a new device
-                    continue;
-                }
-
-                var sessionResult = sessionResults[deviceId];
-                if (!sessionResult.sessionId) {
-                    // no session with this device, probably because there
-                    // were no one-time keys.
-                    //
-                    // we could send them a to_device message anyway, as a
-                    // signal that they have missed out on the key sharing
-                    // message because of the lack of keys, but there's not
-                    // much point in that really; it will mostly serve to clog
-                    // up to_device inboxes.
-                    //
-                    // ensureOlmSessionsForUsers has already done the logging,
-                    // so just skip it.
-                    continue;
-                }
-
-                console.log(
-                    "sharing keys with device " + userId + ":" + deviceId
-                );
-
-                var deviceInfo = sessionResult.device;
-
-                if (!contentMap[userId]) {
-                    contentMap[userId] = {};
-                }
-
-                contentMap[userId][deviceId] =
-                    olmlib.encryptMessageForDevices(
-                        self._deviceId,
-                        self._olmDevice,
-                        [deviceInfo.getIdentityKey()],
-                        payload
-                    );
-                haveTargets = true;
-            }
-        }
-
-        if (!haveTargets) {
-            return q();
-        }
-
-        // TODO: retries
-        return self._baseApis.sendToDevice("m.room.encrypted", contentMap);
-    });
-};
-
-/**
- * @inheritdoc
- *
- * @param {module:models/room} room
- * @param {string} eventType
- * @param {object} plaintext event content
- *
- * @return {module:client.Promise} Promise which resolves to the new event body
- */
-MegolmEncryption.prototype.encryptMessage = function(room, eventType, content) {
-    var self = this;
-    return this._ensureOutboundSession(room).then(function(session_id) {
-        var payloadJson = {
-            room_id: self._roomId,
-            type: eventType,
-            content: content
-        };
-
-        var ciphertext = self._olmDevice.encryptGroupMessage(
-            session_id, JSON.stringify(payloadJson)
-        );
-
-        var encryptedContent = {
-            algorithm: olmlib.MEGOLM_ALGORITHM,
-            sender_key: self._olmDevice.deviceCurve25519Key,
-            ciphertext: ciphertext,
-            session_id: session_id,
-             // Include our device ID so that recipients can send us a
-             // m.new_device message if they don't have our session key.
-            device_id: self._deviceId,
-        };
-
-        return encryptedContent;
-    });
-};
-
-/**
- * @inheritdoc
- *
- * @param {module:models/event.MatrixEvent} event  event causing the change
- * @param {module:models/room-member} member  user whose membership changed
- * @param {string=} oldMembership  previous membership
- */
-MegolmEncryption.prototype.onRoomMembership = function(event, member, oldMembership) {
-    var newMembership = member.membership;
-
-    if (newMembership === 'join') {
-        this._onNewRoomMember(member.userId);
-        return;
-    }
-
-    if (newMembership === 'invite' && oldMembership !== 'join') {
-        // we don't (yet) share keys with invited members, so nothing to do yet
-        return;
-    }
-
-    // otherwise we assume the user is leaving, and start a new outbound session.
-    if (this._outboundSessionId) {
-        console.log("Discarding outbound megolm session due to change in " +
-                    "membership of " + member.userId + " (" + oldMembership +
-                    "->" + newMembership + ")");
-        this._outboundSessionId = null;
-    }
-
-    if (this._prepPromise) {
-        console.log("Discarding as-yet-incomplete megolm session due to " +
-                    "change in membership of " + member.userId + " (" +
-                    oldMembership + "->" + newMembership + ")");
-        this._discardNewSession = true;
-    }
-};
-
-/**
- * handle a new user joining a room
- *
- * @param {string} userId   new member
- */
-MegolmEncryption.prototype._onNewRoomMember = function(userId) {
-    // make sure we have a list of this user's devices. We are happy to use a
-    // cached version here: we assume that if we already have a list of the
-    // user's devices, then we already share an e2e room with them, which means
-    // that they will have announced any new devices via an m.new_device.
-    this._crypto.downloadKeys([userId], false).done();
-
-    // also flag this user up for needing a keyshare.
-    this._devicesPendingKeyShare[userId] = true;
-};
-
-
-/**
- * @inheritdoc
- *
- * @param {string} userId    owner of the device
- * @param {string} deviceId  deviceId of the device
- */
-MegolmEncryption.prototype.onNewDevice = function(userId, deviceId) {
-    var d = this._devicesPendingKeyShare[userId];
-
-    if (d === true) {
-        // we already want to share keys with all devices for this user
-        return;
-    }
-
-    if (!d) {
-        this._devicesPendingKeyShare[userId] = d = {};
-    }
-
-    d[deviceId] = true;
-};
-
-
-/**
- * Megolm decryption implementation
- *
- * @constructor
- * @extends {module:crypto/algorithms/base.DecryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/base.DecryptionAlgorithm}
- */
-function MegolmDecryption(params) {
-    base.DecryptionAlgorithm.call(this, params);
-}
-utils.inherits(MegolmDecryption, base.DecryptionAlgorithm);
-
-/**
- * @inheritdoc
- *
- * @param {object} event raw event
- *
- * @return {null} The event referred to an unknown megolm session
- * @return {module:crypto.DecryptionResult} decryption result
- *
- * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
- *   problem decrypting the event
- */
-MegolmDecryption.prototype.decryptEvent = function(event) {
-    var content = event.content;
-
-    if (!content.sender_key || !content.session_id ||
-        !content.ciphertext
-       ) {
-        throw new base.DecryptionError("Missing fields in input");
-    }
-
-    try {
-        var res = this._olmDevice.decryptGroupMessage(
-            event.room_id, content.sender_key, content.session_id, content.ciphertext
-        );
-        if (res === null) {
-            return null;
-        }
-        return {
-            payload: JSON.parse(res.result),
-            keysClaimed: res.keysClaimed,
-            keysProved: res.keysProved,
-        };
-    } catch (e) {
-        throw new base.DecryptionError(e);
-    }
-};
-
-/**
- * @inheritdoc
- *
- * @param {module:models/event.MatrixEvent} event key event
- */
-MegolmDecryption.prototype.onRoomKeyEvent = function(event) {
-    console.log("Adding key from ", event);
-    var content = event.getContent();
-
-    if (!content.room_id ||
-        !content.session_id ||
-        !content.session_key
-       ) {
-        console.error("key event is missing fields");
-        return;
-    }
-
-    this._olmDevice.addInboundGroupSession(
-        content.room_id, event.getSenderKey(), content.session_id,
-        content.session_key, event.getKeysClaimed()
-    );
-};
-
-base.registerAlgorithm(
-    olmlib.MEGOLM_ALGORITHM, MegolmEncryption, MegolmDecryption
-);

lib/crypto/algorithms/olm.js

@@ -1,271 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * Defines m.olm encryption/decryption
- *
- * @module crypto/algorithms/olm
- */
-var q = require('q');
-
-var utils = require("../../utils");
-var olmlib = require("../olmlib");
-var DeviceInfo = require("../deviceinfo");
-var DeviceVerification = DeviceInfo.DeviceVerification;
-
-
-var base = require("./base");
-
-/**
- * Olm encryption implementation
- *
- * @constructor
- * @extends {module:crypto/algorithms/base.EncryptionAlgorithm}
- *
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/base.EncryptionAlgorithm}
- */
-function OlmEncryption(params) {
-    base.EncryptionAlgorithm.call(this, params);
-    this._sessionPrepared = false;
-    this._prepPromise = null;
-}
-utils.inherits(OlmEncryption, base.EncryptionAlgorithm);
-
-/**
- * @private
-
- * @param {string[]} roomMembers list of currently-joined users in the room
- * @return {module:client.Promise} Promise which resolves when setup is complete
- */
-OlmEncryption.prototype._ensureSession = function(roomMembers) {
-    if (this._prepPromise) {
-        // prep already in progress
-        return this._prepPromise;
-    }
-
-    if (this._sessionPrepared) {
-        // prep already done
-        return q();
-    }
-
-    var self = this;
-    this._prepPromise = self._crypto.downloadKeys(roomMembers, true).then(function(res) {
-        return self._crypto.ensureOlmSessionsForUsers(roomMembers);
-    }).then(function() {
-        self._sessionPrepared = true;
-    }).finally(function() {
-        self._prepPromise = null;
-    });
-    return this._prepPromise;
-};
-
-/**
- * @inheritdoc
- *
- * @param {module:models/room} room
- * @param {string} eventType
- * @param {object} plaintext event content
- *
- * @return {module:client.Promise} Promise which resolves to the new event body
- */
-OlmEncryption.prototype.encryptMessage = function(room, eventType, content) {
-    // pick the list of recipients based on the membership list.
-    //
-    // TODO: there is a race condition here! What if a new user turns up
-    // just as you are sending a secret message?
-
-    var users = utils.map(room.getJoinedMembers(), function(u) {
-        return u.userId;
-    });
-
-    var self = this;
-    return this._ensureSession(users).then(function() {
-        var participantKeys = [];
-        for (var i = 0; i < users.length; ++i) {
-            var userId = users[i];
-            var devices = self._crypto.getStoredDevicesForUser(userId);
-            for (var j = 0; j < devices.length; ++j) {
-                var deviceInfo = devices[j];
-                var key = deviceInfo.getIdentityKey();
-                if (key == self._olmDevice.deviceCurve25519Key) {
-                    // don't bother setting up session to ourself
-                    continue;
-                }
-                if (deviceInfo.verified == DeviceVerification.BLOCKED) {
-                    // don't bother setting up sessions with blocked users
-                    continue;
-                }
-                participantKeys.push(key);
-            }
-        }
-
-        return olmlib.encryptMessageForDevices(
-            self._deviceId, self._olmDevice, participantKeys, {
-                room_id: room.roomId,
-                type: eventType,
-                content: content,
-            }
-        );
-    });
-};
-
-/**
- * Olm decryption implementation
- *
- * @constructor
- * @extends {module:crypto/algorithms/base.DecryptionAlgorithm}
- * @param {object} params parameters, as per
- *     {@link module:crypto/algorithms/base.DecryptionAlgorithm}
- */
-function OlmDecryption(params) {
-    base.DecryptionAlgorithm.call(this, params);
-}
-utils.inherits(OlmDecryption, base.DecryptionAlgorithm);
-
-/**
- * @inheritdoc
- *
- * @param {object} event raw event
- *
- * @return {module:crypto.DecryptionResult} decryption result
- *
- * @throws {module:crypto/algorithms/base.DecryptionError} if there is a
- *   problem decrypting the event
- */
-OlmDecryption.prototype.decryptEvent = function(event) {
-    var content = event.content;
-    var deviceKey = content.sender_key;
-    var ciphertext = content.ciphertext;
-
-    if (!ciphertext) {
-        throw new base.DecryptionError("Missing ciphertext");
-    }
-
-    if (!(this._olmDevice.deviceCurve25519Key in ciphertext)) {
-        throw new base.DecryptionError("Not included in recipients");
-    }
-    var message = ciphertext[this._olmDevice.deviceCurve25519Key];
-    var payloadString;
-
-    try {
-        payloadString = this._decryptMessage(deviceKey, message);
-    } catch (e) {
-        console.warn(
-            "Failed to decrypt Olm event (id=" +
-                event.event_id + ") from " + deviceKey +
-                ": " + e.message
-        );
-        throw new base.DecryptionError("Bad Encrypted Message");
-    }
-
-
-    // TODO: Check the sender user id matches the sender key.
-    // TODO: check the room_id and fingerprint
-    var payload = JSON.parse(payloadString);
-    return {
-        payload: payload,
-        sessionExists: true,
-        keysProved: {curve25519: deviceKey},
-        keysClaimed: payload.keys || {}
-    };
-};
-
-
-/**
- * Attempt to decrypt an Olm message
- *
- * @param {string} theirDeviceIdentityKey  Curve25519 identity key of the sender
- * @param {object} message  message object, with 'type' and 'body' fields
- *
- * @return {string} payload, if decrypted successfully.
- */
-OlmDecryption.prototype._decryptMessage = function(theirDeviceIdentityKey, message) {
-    var sessionIds = this._olmDevice.getSessionIdsForDevice(theirDeviceIdentityKey);
-
-    // try each session in turn.
-    var decryptionErrors = {};
-    for (var i = 0; i < sessionIds.length; i++) {
-        var sessionId = sessionIds[i];
-        try {
-            var payload = this._olmDevice.decryptMessage(
-                theirDeviceIdentityKey, sessionId, message.type, message.body
-            );
-            console.log(
-                "Decrypted Olm message from " + theirDeviceIdentityKey +
-                    " with session " + sessionId
-            );
-            return payload;
-        } catch (e) {
-            var foundSession = this._olmDevice.matchesSession(
-                theirDeviceIdentityKey, sessionId, message.type, message.body
-            );
-
-            if (foundSession) {
-                // decryption failed, but it was a prekey message matching this
-                // session, so it should have worked.
-                throw new Error(
-                    "Error decrypting prekey message with existing session id " +
-                        sessionId + ": " + e.message
-                );
-            }
-
-            // otherwise it's probably a message for another session; carry on, but
-            // keep a record of the error
-            decryptionErrors[sessionId] = e.message;
-        }
-    }
-
-    if (message.type !== 0) {
-        // not a prekey message, so it should have matched an existing session, but it
-        // didn't work.
-
-        if (sessionIds.length === 0) {
-            throw new Error("No existing sessions");
-        }
-
-        throw new Error(
-            "Error decrypting non-prekey message with existing sessions: " +
-                JSON.stringify(decryptionErrors)
-        );
-    }
-
-    // prekey message which doesn't match any existing sessions: make a new
-    // session.
-
-    var res;
-    try {
-        res = this._olmDevice.createInboundSession(
-            theirDeviceIdentityKey, message.type, message.body
-        );
-    } catch (e) {
-        decryptionErrors["(new)"] = e.message;
-        throw new Error(
-            "Error decrypting prekey message: " +
-                JSON.stringify(decryptionErrors)
-        );
-    }
-
-    console.log(
-        "created new inbound Olm session ID " +
-            res.session_id + " with " + theirDeviceIdentityKey
-    );
-    return res.payload;
-};
-
-
-base.registerAlgorithm(olmlib.OLM_ALGORITHM, OlmEncryption, OlmDecryption);

lib/crypto/deviceinfo.js

@@ -1,145 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-
-/**
- * @module crypto/deviceinfo
- */
-
-/**
-  * Information about a user's device
-  *
-  * @constructor
-  * @alias module:crypto/deviceinfo
-  *
-  * @property {string} deviceId the ID of this device
-  *
-  * @property {string[]} algorithms list of algorithms supported by this device
-  *
-  * @property {Object.<string,string>} keys a map from
-  *      &lt;key type&gt;:&lt;id&gt; -> &lt;base64-encoded key&gt;>
-  *
-  * @property {module:crypto/deviceinfo.DeviceVerification} verified
-  *     whether the device has been verified by the user
-  *
-  * @property {Object} unsigned  additional data from the homeserver
-  *
-  * @param {string} deviceId id of the device
-  */
-function DeviceInfo(deviceId) {
-    // you can't change the deviceId
-    Object.defineProperty(this, 'deviceId', {
-        enumerable: true,
-        value: deviceId,
-    });
-
-    this.algorithms = [];
-    this.keys = {};
-    this.verified = DeviceVerification.UNVERIFIED;
-    this.unsigned = {};
-}
-
-/**
- * rehydrate a DeviceInfo from the session store
- *
- * @param {object} obj  raw object from session store
- * @param {string} deviceId id of the device
- *
- * @return {module:crypto~DeviceInfo} new DeviceInfo
- */
-DeviceInfo.fromStorage = function(obj, deviceId) {
-    var res = new DeviceInfo(deviceId);
-    for (var prop in obj) {
-        if (obj.hasOwnProperty(prop)) {
-            res[prop] = obj[prop];
-        }
-    }
-    return res;
-};
-
-/**
- * Prepare a DeviceInfo for JSON serialisation in the session store
- *
- * @return {object} deviceinfo with non-serialised members removed
- */
-DeviceInfo.prototype.toStorage = function() {
-    return {
-        algorithms: this.algorithms,
-        keys: this.keys,
-        verified: this.verified,
-        unsigned: this.unsigned,
-    };
-};
-
-/**
- * Get the fingerprint for this device (ie, the Ed25519 key)
- *
- * @return {string} base64-encoded fingerprint of this device
- */
-DeviceInfo.prototype.getFingerprint = function() {
-    return this.keys["ed25519:" + this.deviceId];
-};
-
-/**
- * Get the identity key for this device (ie, the Curve25519 key)
- *
- * @return {string} base64-encoded identity key of this device
- */
-DeviceInfo.prototype.getIdentityKey = function() {
-    return this.keys["curve25519:" + this.deviceId];
-};
-
-/**
- * Get the configured display name for this device, if any
- *
- * @return {string?} displayname
- */
-DeviceInfo.prototype.getDisplayName = function() {
-    return this.unsigned.device_display_name || null;
-};
-
-/**
- * Returns true if this device is blocked
- *
- * @return {Boolean} true if blocked
- */
-DeviceInfo.prototype.isBlocked = function() {
-    return this.verified == DeviceVerification.BLOCKED;
-};
-
-/**
- * Returns true if this device is verified
- *
- * @return {Boolean} true if verified
- */
-DeviceInfo.prototype.isVerified = function() {
-    return this.verified == DeviceVerification.VERIFIED;
-};
-
-/**
- * @enum
- */
-DeviceInfo.DeviceVerification = {
-    VERIFIED: 1,
-    UNVERIFIED: 0,
-    BLOCKED: -1,
-};
-
-var DeviceVerification = DeviceInfo.DeviceVerification;
-
-/** */
-module.exports = DeviceInfo;

lib/crypto/olmlib.js

@@ -1,90 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-
-/**
- * @module olmlib
- *
- * Utilities common to olm encryption algorithms
- */
-
-var utils = require("../utils");
-
-/**
- * matrix algorithm tag for olm
- */
-module.exports.OLM_ALGORITHM = "m.olm.v1.curve25519-aes-sha2";
-
-/**
- * matrix algorithm tag for megolm
- */
-module.exports.MEGOLM_ALGORITHM = "m.megolm.v1.aes-sha2";
-
-
-/**
- * Encrypt an event payload for a list of devices
- *
- * @param {string} ourDeviceId
- * @param {module:crypto/OlmDevice} olmDevice olm.js wrapper
- * @param {string[]} participantKeys list of curve25519 keys to encrypt for
- * @param {object} payloadFields fields to include in the encrypted payload
- *
- * @return {object} content for an m.room.encrypted event
- */
-module.exports.encryptMessageForDevices = function(
-    ourDeviceId, olmDevice, participantKeys, payloadFields
-) {
-    participantKeys.sort();
-    var participantHash = ""; // Olm.sha256(participantKeys.join());
-    var payloadJson = {
-        fingerprint: participantHash,
-        sender_device: ourDeviceId,
-
-        // Include the Ed25519 key so that the recipient knows what
-        // device this message came from.
-        // We don't need to include the curve25519 key since the
-        // recipient will already know this from the olm headers.
-        // When combined with the device keys retrieved from the
-        // homeserver signed by the ed25519 key this proves that
-        // the curve25519 key and the ed25519 key are owned by
-        // the same device.
-        keys: {
-            "ed25519": olmDevice.deviceEd25519Key,
-        },
-    };
-    utils.extend(payloadJson, payloadFields);
-
-    var ciphertext = {};
-    var payloadString = JSON.stringify(payloadJson);
-    for (var i = 0; i < participantKeys.length; ++i) {
-        var deviceKey = participantKeys[i];
-        var sessionId = olmDevice.getSessionIdForDevice(deviceKey);
-        if (sessionId === null) {
-            // If we don't have a session for a device then
-            // we can't encrypt a message for it.
-            continue;
-        }
-        console.log("Using sessionid " + sessionId + " for device " + deviceKey);
-        ciphertext[deviceKey] = olmDevice.encryptMessage(
-            deviceKey, sessionId, payloadString
-        );
-    }
-    var encryptedContent = {
-        algorithm: module.exports.OLM_ALGORITHM,
-        sender_key: olmDevice.deviceCurve25519Key,
-        ciphertext: ciphertext
-    };
-    return encryptedContent;
-};

lib/filter-component.js

@@ -1,141 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * @module filter-component
- */
-
-/**
- * Checks if a value matches a given field value, which may be a * terminated
- * wildcard pattern.
- * @param {String} actual_value  The value to be compared
- * @param {String} filter_value  The filter pattern to be compared
- * @return {bool} true if the actual_value matches the filter_value
- */
-function _matches_wildcard(actual_value, filter_value) {
-    if (filter_value.endsWith("*")) {
-        var type_prefix = filter_value.slice(0, -1);
-        return actual_value.substr(0, type_prefix.length) === type_prefix;
-    }
-    else {
-        return actual_value === filter_value;
-    }
-}
-
-/**
- * FilterComponent is a section of a Filter definition which defines the
- * types, rooms, senders filters etc to be applied to a particular type of resource.
- * This is all ported over from synapse's Filter object.
- *
- * N.B. that synapse refers to these as 'Filters', and what js-sdk refers to as
- * 'Filters' are referred to as 'FilterCollections'.
- *
- * @constructor
- * @param {Object} the definition of this filter JSON, e.g. { 'contains_url': true }
- */
-function FilterComponent(filter_json) {
-    this.filter_json = filter_json;
-
-    this.types = filter_json.types || null;
-    this.not_types = filter_json.not_types || [];
-
-    this.rooms = filter_json.rooms || null;
-    this.not_rooms = filter_json.not_rooms || [];
-
-    this.senders = filter_json.senders || null;
-    this.not_senders = filter_json.not_senders || [];
-
-    this.contains_url = filter_json.contains_url || null;
-}
-
-/**
- * Checks with the filter component matches the given event
- * @param {MatrixEvent} event event to be checked against the filter
- * @return {bool} true if the event matches the filter
- */
-FilterComponent.prototype.check = function(event) {
-    return this._checkFields(
-        event.getRoomId(),
-        event.getSender(),
-        event.getType(),
-        event.getContent() ? event.getContent().url !== undefined : false
-    );
-};
-
-/**
- * Checks whether the filter component matches the given event fields.
- * @param {String} room_id       the room_id for the event being checked
- * @param {String} sender        the sender of the event being checked
- * @param {String} event_type    the type of the event being checked
- * @param {String} contains_url  whether the event contains a content.url field
- * @return {bool} true if the event fields match the filter
- */
-FilterComponent.prototype._checkFields =
-    function(room_id, sender, event_type, contains_url)
-{
-    var literal_keys = {
-        "rooms": function(v) { return room_id === v; },
-        "senders": function(v) { return sender === v; },
-        "types": function(v) { return _matches_wildcard(event_type, v); },
-    };
-
-    var self = this;
-    Object.keys(literal_keys).forEach(function(name) {
-        var match_func = literal_keys[name];
-        var not_name = "not_" + name;
-        var disallowed_values = self[not_name];
-        if (disallowed_values.map(match_func)) {
-            return false;
-        }
-
-        var allowed_values = self[name];
-        if (allowed_values) {
-            if (!allowed_values.map(match_func)) {
-                return false;
-            }
-        }
-    });
-
-    var contains_url_filter = this.filter_json.contains_url;
-    if (contains_url_filter !== undefined) {
-        if (contains_url_filter !== contains_url) {
-            return false;
-        }
-    }
-
-    return true;
-};
-
-/**
- * Filters a list of events down to those which match this filter component
- * @param {MatrixEvent[]} events  Events to be checked againt the filter component
- * @return {MatrixEvent[]} events which matched the filter component
- */
-FilterComponent.prototype.filter = function(events) {
-    return events.filter(this.check, this);
-};
-
-/**
- * Returns the limit field for a given filter component, providing a default of
- * 10 if none is otherwise specified.  Cargo-culted from Synapse.
- * @return {Number} the limit for this filter component.
- */
-FilterComponent.prototype.limit = function() {
-    return this.filter_json.limit !== undefined ? this.filter_json.limit : 10;
-};
-
-/** The FilterComponent class */
-module.exports = FilterComponent;

lib/filter.js

@@ -1,192 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * @module filter
- */
-
-var FilterComponent = require("./filter-component");
-
-/**
- * @param {Object} obj
- * @param {string} keyNesting
- * @param {*} val
- */
-function setProp(obj, keyNesting, val) {
-    var nestedKeys = keyNesting.split(".");
-    var currentObj = obj;
-    for (var i = 0; i < (nestedKeys.length - 1); i++) {
-        if (!currentObj[nestedKeys[i]]) {
-            currentObj[nestedKeys[i]] = {};
-        }
-        currentObj = currentObj[nestedKeys[i]];
-    }
-    currentObj[nestedKeys[nestedKeys.length - 1]] = val;
-}
-
-/**
- * Construct a new Filter.
- * @constructor
- * @param {string} userId The user ID for this filter.
- * @param {string=} filterId The filter ID if known.
- * @prop {string} userId The user ID of the filter
- * @prop {?string} filterId The filter ID
- */
-function Filter(userId, filterId) {
-    this.userId = userId;
-    this.filterId = filterId;
-    this.definition = {};
-}
-
-/**
- * Get the ID of this filter on your homeserver (if known)
- * @return {?Number} The filter ID
- */
-Filter.prototype.getFilterId = function() {
-    return this.filterId;
-};
-
-/**
- * Get the JSON body of the filter.
- * @return {Object} The filter definition
- */
-Filter.prototype.getDefinition = function() {
-    return this.definition;
-};
-
-/**
- * Set the JSON body of the filter
- * @param {Object} definition The filter definition
- */
-Filter.prototype.setDefinition = function(definition) {
-    this.definition = definition;
-
-    // This is all ported from synapse's FilterCollection()
-
-    // definitions look something like:
-    // {
-    //   "room": {
-    //     "rooms": ["!abcde:example.com"],
-    //     "not_rooms": ["!123456:example.com"],
-    //     "state": {
-    //       "types": ["m.room.*"],
-    //       "not_rooms": ["!726s6s6q:example.com"],
-    //     },
-    //     "timeline": {
-    //       "limit": 10,
-    //       "types": ["m.room.message"],
-    //       "not_rooms": ["!726s6s6q:example.com"],
-    //       "not_senders": ["@spam:example.com"]
-    //       "contains_url": true
-    //     },
-    //     "ephemeral": {
-    //       "types": ["m.receipt", "m.typing"],
-    //       "not_rooms": ["!726s6s6q:example.com"],
-    //       "not_senders": ["@spam:example.com"]
-    //     }
-    //   },
-    //   "presence": {
-    //     "types": ["m.presence"],
-    //     "not_senders": ["@alice:example.com"]
-    //   },
-    //   "event_format": "client",
-    //   "event_fields": ["type", "content", "sender"]
-    // }
-
-    var room_filter_json = definition.room;
-
-    // consider the top level rooms/not_rooms filter
-    var room_filter_fields = {};
-    if (room_filter_json) {
-        if (room_filter_json.rooms) {
-            room_filter_fields.rooms = room_filter_json.rooms;
-        }
-        if (room_filter_json.rooms) {
-            room_filter_fields.not_rooms = room_filter_json.not_rooms;
-        }
-
-        this._include_leave = room_filter_json.include_leave || false;
-    }
-
-    this._room_filter = new FilterComponent(room_filter_fields);
-    this._room_timeline_filter = new FilterComponent(
-        room_filter_json ? (room_filter_json.timeline || {}) : {}
-    );
-
-    // don't bother porting this from synapse yet:
-    // this._room_state_filter =
-    //     new FilterComponent(room_filter_json.state || {});
-    // this._room_ephemeral_filter =
-    //     new FilterComponent(room_filter_json.ephemeral || {});
-    // this._room_account_data_filter =
-    //     new FilterComponent(room_filter_json.account_data || {});
-    // this._presence_filter =
-    //     new FilterComponent(definition.presence || {});
-    // this._account_data_filter =
-    //     new FilterComponent(definition.account_data || {});
-};
-
-/**
- * Get the room.timeline filter component of the filter
- * @return {FilterComponent} room timeline filter component
- */
-Filter.prototype.getRoomTimelineFilterComponent = function() {
-    return this._room_timeline_filter;
-};
-
-/**
- * Filter the list of events based on whether they are allowed in a timeline
- * based on this filter
- * @param {MatrixEvent[]} events  the list of events being filtered
- * @return {MatrixEvent[]} the list of events which match the filter
- */
-Filter.prototype.filterRoomTimeline = function(events) {
-    return this._room_timeline_filter.filter(this._room_filter.filter(events));
-};
-
-/**
- * Set the max number of events to return for each room's timeline.
- * @param {Number} limit The max number of events to return for each room.
- */
-Filter.prototype.setTimelineLimit = function(limit) {
-    setProp(this.definition, "room.timeline.limit", limit);
-};
-
-/**
- * Control whether left rooms should be included in responses.
- * @param {boolean} includeLeave True to make rooms the user has left appear
- * in responses.
- */
-Filter.prototype.setIncludeLeaveRooms = function(includeLeave) {
-    setProp(this.definition, "room.include_leave", includeLeave);
-};
-
-/**
- * Create a filter from existing data.
- * @static
- * @param {string} userId
- * @param {string} filterId
- * @param {Object} jsonObj
- * @return {Filter}
- */
-Filter.fromJson = function(userId, filterId, jsonObj) {
-    var filter = new Filter(userId, filterId);
-    filter.setDefinition(jsonObj);
-    return filter;
-};
-
-/** The Filter class */
-module.exports = Filter;

lib/http-api.js

@@ -1,767 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * This is an internal module. See {@link MatrixHttpApi} for the public class.
- * @module http-api
- */
-var q = require("q");
-var utils = require("./utils");
-
-// we use our own implementation of setTimeout, so that if we get suspended in
-// the middle of a /sync, we cancel the sync as soon as we awake, rather than
-// waiting for the delay to elapse.
-var callbacks = require("./realtime-callbacks");
-
-/*
-TODO:
-- CS: complete register function (doing stages)
-- Identity server: linkEmail, authEmail, bindEmail, lookup3pid
-*/
-
-/**
- * A constant representing the URI path for release 0 of the Client-Server HTTP API.
- */
-module.exports.PREFIX_R0 = "/_matrix/client/r0";
-
-/**
- * A constant representing the URI path for as-yet unspecified Client-Server HTTP APIs.
- */
-module.exports.PREFIX_UNSTABLE = "/_matrix/client/unstable";
-
-/**
- * URI path for the identity API
- */
-module.exports.PREFIX_IDENTITY_V1 = "/_matrix/identity/api/v1";
-
-/**
- * URI path for the media repo API
- */
-module.exports.PREFIX_MEDIA_R0 = "/_matrix/media/r0";
-
-/**
- * Construct a MatrixHttpApi.
- * @constructor
- * @param {EventEmitter} event_emitter The event emitter to use for emitting events
- * @param {Object} opts The options to use for this HTTP API.
- * @param {string} opts.baseUrl Required. The base client-server URL e.g.
- * 'http://localhost:8008'.
- * @param {Function} opts.request Required. The function to call for HTTP
- * requests. This function must look like function(opts, callback){ ... }.
- * @param {string} opts.prefix Required. The matrix client prefix to use, e.g.
- * '/_matrix/client/r0'. See PREFIX_R0 and PREFIX_UNSTABLE for constants.
- *
- * @param {bool=} opts.onlyData True to return only the 'data' component of the
- * response (e.g. the parsed HTTP body). If false, requests will return an
- * object with the properties <tt>code</tt>, <tt>headers</tt> and <tt>data</tt>.
- *
- * @param {string} opts.accessToken The access_token to send with requests. Can be
- * null to not send an access token.
- * @param {Object} opts.extraParams Optional. Extra query parameters to send on
- * requests.
- */
-module.exports.MatrixHttpApi = function MatrixHttpApi(event_emitter, opts) {
-    utils.checkObjectHasKeys(opts, ["baseUrl", "request", "prefix"]);
-    opts.onlyData = opts.onlyData || false;
-    this.event_emitter = event_emitter;
-    this.opts = opts;
-    this.uploads = [];
-};
-
-module.exports.MatrixHttpApi.prototype = {
-
-    /**
-     * Get the content repository url with query parameters.
-     * @return {Object} An object with a 'base', 'path' and 'params' for base URL,
-     *          path and query parameters respectively.
-     */
-    getContentUri: function() {
-        var params = {
-            access_token: this.opts.accessToken
-        };
-        return {
-            base: this.opts.baseUrl,
-            path: "/_matrix/media/v1/upload",
-            params: params
-        };
-    },
-
-    /**
-     * Upload content to the Home Server
-     *
-     * @param {object} file The object to upload. On a browser, something that
-     *   can be sent to XMLHttpRequest.send (typically a File).  Under node.js,
-     *   a a Buffer, String or ReadStream.
-     *
-     * @param {object} opts  options object
-     *
-     * @param {string=} opts.name   Name to give the file on the server. Defaults
-     *   to <tt>file.name</tt>.
-     *
-     * @param {string=} opts.type   Content-type for the upload. Defaults to
-     *   <tt>file.type</tt>, or <tt>applicaton/octet-stream</tt>.
-     *
-     * @param {boolean=} opts.rawResponse Return the raw body, rather than
-     *   parsing the JSON. Defaults to false (except on node.js, where it
-     *   defaults to true for backwards compatibility).
-     *
-     * @param {boolean=} opts.onlyContentUri Just return the content URI,
-     *   rather than the whole body. Defaults to false (except on browsers,
-     *   where it defaults to true for backwards compatibility). Ignored if
-     *   opts.rawResponse is true.
-     *
-     * @param {Function=} opts.callback Deprecated. Optional. The callback to
-     *    invoke on success/failure. See the promise return values for more
-     *    information.
-     *
-     * @return {module:client.Promise} Resolves to response object, as
-     *    determined by this.opts.onlyData, opts.rawResponse, and
-     *    opts.onlyContentUri.  Rejects with an error (usually a MatrixError).
-     */
-    uploadContent: function(file, opts) {
-        if (utils.isFunction(opts)) {
-            // opts used to be callback
-            opts = {
-                callback: opts,
-            };
-        } else if (opts === undefined) {
-            opts = {};
-        }
-
-        // if the file doesn't have a mime type, use a default since
-        // the HS errors if we don't supply one.
-        var contentType = opts.type || file.type || 'application/octet-stream';
-        var fileName = opts.name || file.name;
-
-        // we used to recommend setting file.stream to the thing to upload on
-        // nodejs.
-        var body = file.stream ? file.stream : file;
-
-        // backwards-compatibility hacks where we used to do different things
-        // between browser and node.
-        var rawResponse = opts.rawResponse;
-        if (rawResponse === undefined) {
-            if (global.XMLHttpRequest) {
-                rawResponse = false;
-            } else {
-                console.warn(
-                    "Returning the raw JSON from uploadContent(). Future " +
-                    "versions of the js-sdk will change this default, to " +
-                    "return the parsed object. Set opts.rawResponse=false " +
-                    "to change this behaviour now."
-                );
-                rawResponse = true;
-            }
-        }
-
-        var onlyContentUri = opts.onlyContentUri;
-        if (!rawResponse && onlyContentUri === undefined) {
-            if (global.XMLHttpRequest) {
-                console.warn(
-                    "Returning only the content-uri from uploadContent(). " +
-                    "Future versions of the js-sdk will change this " +
-                    "default, to return the whole response object. Set " +
-                    "opts.onlyContentUri=false to change this behaviour now."
-                );
-                onlyContentUri = true;
-            } else {
-                onlyContentUri = false;
-            }
-        }
-
-        // browser-request doesn't support File objects because it deep-copies
-        // the options using JSON.parse(JSON.stringify(options)). Instead of
-        // loading the whole file into memory as a string and letting
-        // browser-request base64 encode and then decode it again, we just
-        // use XMLHttpRequest directly.
-        // (browser-request doesn't support progress either, which is also kind
-        // of important here)
-
-        var upload = { loaded: 0, total: 0 };
-        var promise;
-
-        // XMLHttpRequest doesn't parse JSON for us. request normally does, but
-        // we're setting opts.json=false so that it doesn't JSON-encode the
-        // request, which also means it doesn't JSON-decode the response. Either
-        // way, we have to JSON-parse the response ourselves.
-        var bodyParser = null;
-        if (!rawResponse) {
-            bodyParser = function(rawBody) {
-                var body = JSON.parse(rawBody);
-                if (onlyContentUri) {
-                    body = body.content_uri;
-                    if (body === undefined) {
-                        throw Error('Bad response');
-                    }
-                }
-                return body;
-            };
-        }
-
-        if (global.XMLHttpRequest) {
-            var defer = q.defer();
-            var xhr = new global.XMLHttpRequest();
-            upload.xhr = xhr;
-            var cb = requestCallback(defer, opts.callback, this.opts.onlyData);
-
-            var timeout_fn = function() {
-                xhr.abort();
-                cb(new Error('Timeout'));
-            };
-
-            // set an initial timeout of 30s; we'll advance it each time we get
-            // a progress notification
-            xhr.timeout_timer = callbacks.setTimeout(timeout_fn, 30000);
-
-            xhr.onreadystatechange = function() {
-                switch (xhr.readyState) {
-                    case global.XMLHttpRequest.DONE:
-                        callbacks.clearTimeout(xhr.timeout_timer);
-                        var resp;
-                        try {
-                            if (!xhr.responseText) {
-                                throw new Error('No response body.');
-                            }
-                            resp = xhr.responseText;
-                            if (bodyParser) {
-                                resp = bodyParser(resp);
-                            }
-                        } catch (err) {
-                            err.http_status = xhr.status;
-                            cb(err);
-                            return;
-                        }
-                        cb(undefined, xhr, resp);
-                        break;
-                }
-            };
-            xhr.upload.addEventListener("progress", function(ev) {
-                callbacks.clearTimeout(xhr.timeout_timer);
-                upload.loaded = ev.loaded;
-                upload.total = ev.total;
-                xhr.timeout_timer = callbacks.setTimeout(timeout_fn, 30000);
-                defer.notify(ev);
-            });
-            var url = this.opts.baseUrl + "/_matrix/media/v1/upload";
-            url += "?access_token=" + encodeURIComponent(this.opts.accessToken);
-            url += "&filename=" + encodeURIComponent(fileName);
-
-            xhr.open("POST", url);
-            xhr.setRequestHeader("Content-Type", contentType);
-            xhr.send(body);
-            promise = defer.promise;
-
-            // dirty hack (as per _request) to allow the upload to be cancelled.
-            promise.abort = xhr.abort.bind(xhr);
-        } else {
-            var queryParams = {
-                filename: fileName,
-            };
-
-            promise = this.authedRequest(
-                opts.callback, "POST", "/upload", queryParams, body, {
-                    prefix: "/_matrix/media/v1",
-                    headers: {"Content-Type": contentType},
-                    json: false,
-                    bodyParser: bodyParser,
-                }
-            );
-        }
-
-        var self = this;
-
-        // remove the upload from the list on completion
-        var promise0 = promise.finally(function() {
-            for (var i = 0; i < self.uploads.length; ++i) {
-                if (self.uploads[i] === upload) {
-                    self.uploads.splice(i, 1);
-                    return;
-                }
-            }
-        });
-
-        // copy our dirty abort() method to the new promise
-        promise0.abort = promise.abort;
-
-        upload.promise = promise0;
-        this.uploads.push(upload);
-
-        return promise0;
-    },
-
-    cancelUpload: function(promise) {
-        if (promise.abort) {
-            promise.abort();
-            return true;
-        }
-        return false;
-    },
-
-    getCurrentUploads: function() {
-        return this.uploads;
-    },
-
-    idServerRequest: function(callback, method, path, params, prefix) {
-        var fullUri = this.opts.idBaseUrl + prefix + path;
-
-        if (callback !== undefined && !utils.isFunction(callback)) {
-            throw Error(
-                "Expected callback to be a function but got " + typeof callback
-            );
-        }
-
-        var opts = {
-            uri: fullUri,
-            method: method,
-            withCredentials: false,
-            json: false,
-            _matrix_opts: this.opts
-        };
-        if (method == 'GET') {
-            opts.qs = params;
-        } else {
-            opts.form = params;
-        }
-
-        var defer = q.defer();
-        this.opts.request(
-            opts,
-            requestCallback(defer, callback, this.opts.onlyData)
-        );
-        // ID server does not always take JSON, so we can't use requests' 'json'
-        // option as we do with the home server, but it does return JSON, so
-        // parse it manually
-        return defer.promise.then(function(response) {
-            return JSON.parse(response);
-        });
-    },
-
-    /**
-     * Perform an authorised request to the homeserver.
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
-     * "/createRoom".
-     *
-     * @param {Object=} queryParams A dict of query params (these will NOT be
-     * urlencoded). If unspecified, there will be no query params.
-     *
-     * @param {Object} data The HTTP JSON body.
-     *
-     * @param {Object=} opts additional options
-     *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     *
-     * @param {sting=} opts.prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
-     *
-     * @param {Object=} opts.headers map of additional request headers
-     *
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
-     */
-    authedRequest: function(callback, method, path, queryParams, data, opts) {
-        if (!queryParams) {
-            queryParams = {};
-        }
-        if (!queryParams.access_token) {
-            queryParams.access_token = this.opts.accessToken;
-        }
-
-        var request_promise = this.request(
-            callback, method, path, queryParams, data, opts
-        );
-
-        var self = this;
-        request_promise.catch(function(err) {
-            if (err.errcode == 'M_UNKNOWN_TOKEN') {
-                self.event_emitter.emit("Session.logged_out");
-            }
-        });
-
-        // return the original promise, otherwise tests break due to it having to
-        // go around the event loop one more time to process the result of the request
-        return request_promise;
-    },
-
-    /**
-     * Perform a request to the homeserver without any credentials.
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
-     * "/createRoom".
-     *
-     * @param {Object=} queryParams A dict of query params (these will NOT be
-     * urlencoded). If unspecified, there will be no query params.
-     *
-     * @param {Object} data The HTTP JSON body.
-     *
-     * @param {Object=} opts additional options
-     *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     *
-     * @param {sting=} opts.prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
-     *
-     * @param {Object=} opts.headers map of additional request headers
-     *
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
-     */
-    request: function(callback, method, path, queryParams, data, opts) {
-        opts = opts || {};
-        var prefix = opts.prefix !== undefined ? opts.prefix : this.opts.prefix;
-        var fullUri = this.opts.baseUrl + prefix + path;
-
-        return this.requestOtherUrl(
-            callback, method, fullUri, queryParams, data, opts
-        );
-    },
-
-    /**
-     * Perform an authorised request to the homeserver with a specific path
-     * prefix which overrides the default for this call only. Useful for hitting
-     * different Matrix Client-Server versions.
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
-     * "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
-     * @param {Object} data The HTTP JSON body.
-     * @param {string} prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha".
-     * @param {Number=} localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
-     *
-     * @deprecated prefer authedRequest with opts.prefix
-     */
-    authedRequestWithPrefix: function(callback, method, path, queryParams, data,
-                                      prefix, localTimeoutMs) {
-        return this.authedRequest(
-            callback, method, path, queryParams, data, {
-                localTimeoutMs: localTimeoutMs,
-                prefix: prefix,
-            }
-        );
-    },
-
-    /**
-     * Perform a request to the homeserver without any credentials but with a
-     * specific path prefix which overrides the default for this call only.
-     * Useful for hitting different Matrix Client-Server versions.
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
-     * "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
-     * @param {Object} data The HTTP JSON body.
-     * @param {string} prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha".
-     * @param {Number=} localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
-     *
-     * @deprecated prefer request with opts.prefix
-     */
-    requestWithPrefix: function(callback, method, path, queryParams, data, prefix,
-                                localTimeoutMs) {
-        return this.request(
-            callback, method, path, queryParams, data, {
-                localTimeoutMs: localTimeoutMs,
-                prefix: prefix,
-            }
-        );
-    },
-
-    /**
-     * Perform a request to an arbitrary URL.
-     * @param {Function} callback Optional. The callback to invoke on
-     * success/failure. See the promise return values for more information.
-     * @param {string} method The HTTP method e.g. "GET".
-     * @param {string} uri The HTTP URI
-     *
-     * @param {Object=} queryParams A dict of query params (these will NOT be
-     * urlencoded). If unspecified, there will be no query params.
-     *
-     * @param {Object} data The HTTP JSON body.
-     *
-     * @param {Object=} opts additional options
-     *
-     * @param {Number=} opts.localTimeoutMs The maximum amount of time to wait before
-     * timing out the request. If not specified, there is no timeout.
-     *
-     * @param {sting=} opts.prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha". If not specified, uses this.opts.prefix.
-     *
-     * @param {Object=} opts.headers map of additional request headers
-     *
-     * @return {module:client.Promise} Resolves to <code>{data: {Object},
-     * headers: {Object}, code: {Number}}</code>.
-     * If <code>onlyData</code> is set, this will resolve to the <code>data</code>
-     * object only.
-     * @return {module:http-api.MatrixError} Rejects with an error if a problem
-     * occurred. This includes network problems and Matrix-specific error JSON.
-     */
-    requestOtherUrl: function(callback, method, uri, queryParams, data,
-                              opts) {
-        if (opts === undefined || opts === null) {
-            opts = {};
-        } else if (isFinite(opts)) {
-            // opts used to be localTimeoutMs
-            opts = {
-                localTimeoutMs: opts
-            };
-        }
-
-        return this._request(
-            callback, method, uri, queryParams, data, opts
-        );
-    },
-
-    /**
-     * Form and return a homeserver request URL based on the given path
-     * params and prefix.
-     * @param {string} path The HTTP path <b>after</b> the supplied prefix e.g.
-     * "/createRoom".
-     * @param {Object} queryParams A dict of query params (these will NOT be
-     * urlencoded).
-     * @param {string} prefix The full prefix to use e.g.
-     * "/_matrix/client/v2_alpha".
-     * @return {string} URL
-     */
-    getUrl: function(path, queryParams, prefix) {
-        var queryString = "";
-        if (queryParams) {
-            queryString = "?" + utils.encodeParams(queryParams);
-        }
-        return this.opts.baseUrl + prefix + path + queryString;
-    },
-
-    /**
-     * @private
-     *
-     * @param {function} callback
-     * @param {string} method
-     * @param {string} uri
-     * @param {object} queryParams
-     * @param {object|string} data
-     * @param {object=} opts
-     *
-     * @param {boolean=true} opts.json Json-encode data before sending, and
-     *   decode response on receipt. (We will still json-decode error
-     *   responses, even if this is false.)
-     *
-     * @param {object=} opts.headers  extra request headers
-     *
-     * @param {number=} opts.localTimeoutMs client-side timeout for the
-     *    request. No timeout if undefined.
-     *
-     * @param {function=} opts.bodyParser function to parse the body of the
-     *    response before passing it to the promise and callback.
-     *
-     * @return {module:client.Promise} a promise which resolves to either the
-     * response object (if this.opts.onlyData is truthy), or the parsed
-     * body. Rejects
-     */
-    _request: function(callback, method, uri, queryParams, data, opts) {
-        if (callback !== undefined && !utils.isFunction(callback)) {
-            throw Error(
-                "Expected callback to be a function but got " + typeof callback
-            );
-        }
-        opts = opts || {};
-
-        var self = this;
-        if (this.opts.extraParams) {
-            for (var key in this.opts.extraParams) {
-                if (!this.opts.extraParams.hasOwnProperty(key)) { continue; }
-                queryParams[key] = this.opts.extraParams[key];
-            }
-        }
-
-        var json = opts.json === undefined ? true : opts.json;
-
-        var defer = q.defer();
-
-        var timeoutId;
-        var timedOut = false;
-        var req;
-        var localTimeoutMs = opts.localTimeoutMs;
-        if (localTimeoutMs) {
-            timeoutId = callbacks.setTimeout(function() {
-                timedOut = true;
-                if (req && req.abort) {
-                    req.abort();
-                }
-                defer.reject(new module.exports.MatrixError({
-                    error: "Locally timed out waiting for a response",
-                    errcode: "ORG.MATRIX.JSSDK_TIMEOUT",
-                    timeout: localTimeoutMs
-                }));
-            }, localTimeoutMs);
-        }
-
-        var reqPromise = defer.promise;
-
-        try {
-            req = this.opts.request(
-                {
-                    uri: uri,
-                    method: method,
-                    withCredentials: false,
-                    qs: queryParams,
-                    body: data,
-                    json: json,
-                    timeout: localTimeoutMs,
-                    headers: opts.headers || {},
-                    _matrix_opts: this.opts
-                },
-                function(err, response, body) {
-                    if (localTimeoutMs) {
-                        callbacks.clearTimeout(timeoutId);
-                        if (timedOut) {
-                            return; // already rejected promise
-                        }
-                    }
-
-                    // if json is falsy, we won't parse any error response, so need
-                    // to do so before turning it into a MatrixError
-                    var parseErrorJson = !json;
-                    var handlerFn = requestCallback(
-                        defer, callback, self.opts.onlyData,
-                        parseErrorJson,
-                        opts.bodyParser
-                    );
-                    handlerFn(err, response, body);
-                }
-            );
-            if (req && req.abort) {
-                // FIXME: This is EVIL, but I can't think of a better way to expose
-                // abort() operations on underlying HTTP requests :(
-                reqPromise.abort = req.abort.bind(req);
-            }
-        }
-        catch (ex) {
-            defer.reject(ex);
-            if (callback) {
-                callback(ex);
-            }
-        }
-        return reqPromise;
-    }
-};
-
-/*
- * Returns a callback that can be invoked by an HTTP request on completion,
- * that will either resolve or reject the given defer as well as invoke the
- * given userDefinedCallback (if any).
- *
- * If onlyData is true, the defer/callback is invoked with the body of the
- * response, otherwise the result code.
- *
- * If parseErrorJson is true, we will JSON.parse the body if we get a 4xx error.
- *
- */
-var requestCallback = function(
-    defer, userDefinedCallback, onlyData,
-    parseErrorJson, bodyParser
-) {
-    userDefinedCallback = userDefinedCallback || function() {};
-
-    return function(err, response, body) {
-        if (!err) {
-            try {
-                if (response.statusCode >= 400) {
-                    if (parseErrorJson) {
-                        // we won't have json-decoded the response.
-                        body = JSON.parse(body);
-                    }
-                    err = new module.exports.MatrixError(body);
-                } else if (bodyParser) {
-                    body = bodyParser(body);
-                }
-            } catch (e) {
-                err = e;
-            }
-            if (err) {
-                err.httpStatus = response.statusCode;
-            }
-        }
-
-        if (err) {
-            defer.reject(err);
-            userDefinedCallback(err);
-        }
-        else {
-            var res = {
-                code: response.statusCode,
-                headers: response.headers,
-                data: body
-            };
-            defer.resolve(onlyData ? body : res);
-            userDefinedCallback(null, onlyData ? body : res);
-        }
-    };
-};
-
-/**
- * Construct a Matrix error. This is a JavaScript Error with additional
- * information specific to the standard Matrix error response.
- * @constructor
- * @param {Object} errorJson The Matrix error JSON returned from the homeserver.
- * @prop {string} errcode The Matrix 'errcode' value, e.g. "M_FORBIDDEN".
- * @prop {string} name Same as MatrixError.errcode but with a default unknown string.
- * @prop {string} message The Matrix 'error' value, e.g. "Missing token."
- * @prop {Object} data The raw Matrix error JSON used to construct this object.
- * @prop {integer} httpStatus The numeric HTTP status code given
- */
-module.exports.MatrixError = function MatrixError(errorJson) {
-    errorJson = errorJson || {};
-    this.errcode = errorJson.errcode;
-    this.name = errorJson.errcode || "Unknown error code";
-    this.message = errorJson.error || "Unknown message";
-    this.data = errorJson;
-};
-module.exports.MatrixError.prototype = Object.create(Error.prototype);
-/** */
-module.exports.MatrixError.prototype.constructor = module.exports.MatrixError;

lib/matrix.js

@@ -1,139 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/** The {@link module:models/event.MatrixEvent|MatrixEvent} class. */
-module.exports.MatrixEvent = require("./models/event").MatrixEvent;
-/** The {@link module:models/event.EventStatus|EventStatus} enum. */
-module.exports.EventStatus = require("./models/event").EventStatus;
-/** The {@link module:store/memory.MatrixInMemoryStore|MatrixInMemoryStore} class. */
-module.exports.MatrixInMemoryStore = require("./store/memory").MatrixInMemoryStore;
-/** The {@link module:store/webstorage~WebStorageStore|WebStorageStore} class.
- * <strong>Work in progress; unstable.</strong> */
-module.exports.WebStorageStore = require("./store/webstorage");
-/** The {@link module:http-api.MatrixHttpApi|MatrixHttpApi} class. */
-module.exports.MatrixHttpApi = require("./http-api").MatrixHttpApi;
-/** The {@link module:http-api.MatrixError|MatrixError} class. */
-module.exports.MatrixError = require("./http-api").MatrixError;
-/** The {@link module:client.MatrixClient|MatrixClient} class. */
-module.exports.MatrixClient = require("./client").MatrixClient;
-/** The {@link module:models/room|Room} class. */
-module.exports.Room = require("./models/room");
-/** The {@link module:models/event-timeline~EventTimeline} class. */
-module.exports.EventTimeline = require("./models/event-timeline");
-/** The {@link module:models/event-timeline-set~EventTimelineSet} class. */
-module.exports.EventTimelineSet = require("./models/event-timeline-set");
-/** The {@link module:models/room-member|RoomMember} class. */
-module.exports.RoomMember = require("./models/room-member");
-/** The {@link module:models/room-state~RoomState|RoomState} class. */
-module.exports.RoomState = require("./models/room-state");
-/** The {@link module:models/user~User|User} class. */
-module.exports.User = require("./models/user");
-/** The {@link module:scheduler~MatrixScheduler|MatrixScheduler} class. */
-module.exports.MatrixScheduler = require("./scheduler");
-/** The {@link module:store/session/webstorage~WebStorageSessionStore|
- * WebStorageSessionStore} class. <strong>Work in progress; unstable.</strong> */
-module.exports.WebStorageSessionStore = require("./store/session/webstorage");
-/** True if crypto libraries are being used on this client. */
-module.exports.CRYPTO_ENABLED = require("./client").CRYPTO_ENABLED;
-/** {@link module:content-repo|ContentRepo} utility functions. */
-module.exports.ContentRepo = require("./content-repo");
-/** The {@link module:filter~Filter|Filter} class. */
-module.exports.Filter = require("./filter");
-/** The {@link module:timeline-window~TimelineWindow} class. */
-module.exports.TimelineWindow = require("./timeline-window").TimelineWindow;
-
-/**
- * Create a new Matrix Call.
- * @function
- * @param {module:client.MatrixClient} client The MatrixClient instance to use.
- * @param {string} roomId The room the call is in.
- * @return {module:webrtc/call~MatrixCall} The Matrix call or null if the browser
- * does not support WebRTC.
- */
-module.exports.createNewMatrixCall = require("./webrtc/call").createNewMatrixCall;
-
-// expose the underlying request object so different environments can use
-// different request libs (e.g. request or browser-request)
-var request;
-/**
- * The function used to perform HTTP requests. Only use this if you want to
- * use a different HTTP library, e.g. Angular's <code>$http</code>. This should
- * be set prior to calling {@link createClient}.
- * @param {requestFunction} r The request function to use.
- */
-module.exports.request = function(r) {
-    request = r;
-};
-
-/**
- * Construct a Matrix Client. Similar to {@link module:client~MatrixClient}
- * except that the 'request', 'store' and 'scheduler' dependencies are satisfied.
- * @param {(Object|string)} opts The configuration options for this client. If
- * this is a string, it is assumed to be the base URL. These configuration
- * options will be passed directly to {@link module:client~MatrixClient}.
- * @param {Object} opts.store If not set, defaults to
- * {@link module:store/memory.MatrixInMemoryStore}.
- * @param {Object} opts.scheduler If not set, defaults to
- * {@link module:scheduler~MatrixScheduler}.
- * @param {requestFunction} opts.request If not set, defaults to the function
- * supplied to {@link request} which defaults to the request module from NPM.
- * @return {MatrixClient} A new matrix client.
- * @see {@link module:client~MatrixClient} for the full list of options for
- * <code>opts</code>.
- */
-module.exports.createClient = function(opts) {
-    if (typeof opts === "string") {
-        opts = {
-            "baseUrl": opts
-        };
-    }
-    opts.request = opts.request || request;
-    opts.store = opts.store || new module.exports.MatrixInMemoryStore({
-      localStorage: global.localStorage
-    });
-    opts.scheduler = opts.scheduler || new module.exports.MatrixScheduler();
-    return new module.exports.MatrixClient(opts);
-};
-
-/**
- * The request function interface for performing HTTP requests. This matches the
- * API for the {@link https://github.com/request/request#requestoptions-callback|
- * request NPM module}. The SDK will attempt to call this function in order to
- * perform an HTTP request.
- * @callback requestFunction
- * @param {Object} opts The options for this HTTP request.
- * @param {string} opts.uri The complete URI.
- * @param {string} opts.method The HTTP method.
- * @param {Object} opts.qs The query parameters to append to the URI.
- * @param {Object} opts.body The JSON-serializable object.
- * @param {boolean} opts.json True if this is a JSON request.
- * @param {Object} opts._matrix_opts The underlying options set for
- * {@link MatrixHttpApi}.
- * @param {requestCallback} callback The request callback.
- */
-
- /**
-  * The request callback interface for performing HTTP requests. This matches the
-  * API for the {@link https://github.com/request/request#requestoptions-callback|
-  * request NPM module}. The SDK will implement a callback which meets this
-  * interface in order to handle the HTTP response.
-  * @callback requestCallback
-  * @param {Error} err The error if one occurred, else falsey.
-  * @param {Object} response The HTTP response which consists of
-  * <code>{statusCode: {Number}, headers: {Object}}</code>
-  * @param {Object} body The parsed HTTP response body.
-  */

lib/models/event-context.js

@@ -1,119 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * @module models/event-context
- */
-
-/**
- * Construct a new EventContext
- *
- * An eventcontext is used for circumstances such as search results, when we
- * have a particular event of interest, and a bunch of events before and after
- * it.
- *
- * It also stores pagination tokens for going backwards and forwards in the
- * timeline.
- *
- * @param {MatrixEvent} ourEvent  the event at the centre of this context
- *
- * @constructor
- */
-function EventContext(ourEvent) {
-    this._timeline = [ourEvent];
-    this._ourEventIndex = 0;
-    this._paginateTokens = {b: null, f: null};
-
-    // this is used by MatrixClient to keep track of active requests
-    this._paginateRequests = {b: null, f: null};
-}
-
-/**
- * Get the main event of interest
- *
- * This is a convenience function for getTimeline()[getOurEventIndex()].
- *
- * @return {MatrixEvent} The event at the centre of this context.
- */
-EventContext.prototype.getEvent = function() {
-    return this._timeline[this._ourEventIndex];
-};
-
-/**
- * Get the list of events in this context
- *
- * @return {Array} An array of MatrixEvents
- */
-EventContext.prototype.getTimeline = function() {
-    return this._timeline;
-};
-
-/**
- * Get the index in the timeline of our event
- *
- * @return {Number}
- */
-EventContext.prototype.getOurEventIndex = function() {
-    return this._ourEventIndex;
-};
-
-/**
- * Get a pagination token.
- *
- * @param {boolean} backwards   true to get the pagination token for going
- *                                  backwards in time
- * @return {string}
- */
-EventContext.prototype.getPaginateToken = function(backwards) {
-    return this._paginateTokens[backwards ? 'b' : 'f'];
-};
-
-/**
- * Set a pagination token.
- *
- * Generally this will be used only by the matrix js sdk.
- *
- * @param {string} token        pagination token
- * @param {boolean} backwards   true to set the pagination token for going
- *                                   backwards in time
- */
-EventContext.prototype.setPaginateToken = function(token, backwards) {
-    this._paginateTokens[backwards ? 'b' : 'f'] = token;
-};
-
-/**
- * Add more events to the timeline
- *
- * @param {Array} events      new events, in timeline order
- * @param {boolean} atStart   true to insert new events at the start
- */
-EventContext.prototype.addEvents = function(events, atStart) {
-    // TODO: should we share logic with Room.addEventsToTimeline?
-    // Should Room even use EventContext?
-
-    if (atStart) {
-        this._timeline = events.concat(this._timeline);
-        this._ourEventIndex += events.length;
-    } else {
-        this._timeline = this._timeline.concat(events);
-    }
-};
-
-/**
- * The EventContext class
- */
-module.exports = EventContext;

lib/models/event-timeline-set.js

@@ -1,654 +0,0 @@
-/*
-Copyright 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * @module models/event-timeline-set
- */
-var EventEmitter = require("events").EventEmitter;
-var utils = require("../utils");
-var EventTimeline = require("./event-timeline");
-
-// var DEBUG = false;
-var DEBUG = true;
-
-if (DEBUG) {
-    // using bind means that we get to keep useful line numbers in the console
-    var debuglog = console.log.bind(console);
-} else {
-    var debuglog = function() {};
-}
-
-/**
- * Construct a set of EventTimeline objects, typically on behalf of a given
- * room.  A room may have multiple EventTimelineSets for different levels
- * of filtering.  The global notification list is also an EventTimelineSet, but
- * lacks a room.
- *
- * <p>This is an ordered sequence of timelines, which may or may not
- * be continuous. Each timeline lists a series of events, as well as tracking
- * the room state at the start and the end of the timeline (if appropriate).
- * It also tracks forward and backward pagination tokens, as well as containing
- * links to the next timeline in the sequence.
- *
- * <p>There is one special timeline - the 'live' timeline, which represents the
- * timeline to which events are being added in real-time as they are received
- * from the /sync API. Note that you should not retain references to this
- * timeline - even if it is the current timeline right now, it may not remain
- * so if the server gives us a timeline gap in /sync.
- *
- * <p>In order that we can find events from their ids later, we also maintain a
- * map from event_id to timeline and index.
- *
- * @constructor
- * @param {?Room} room      the optional room for this timelineSet
- * @param {Object} opts     hash of options inherited from Room.
- *      opts.timelineSupport gives whether timeline support is enabled
- *      opts.filter is the filter object, if any, for this timelineSet.
- */
-function EventTimelineSet(room, opts) {
-    this.room = room;
-
-    this._timelineSupport = Boolean(opts.timelineSupport);
-    this._liveTimeline = new EventTimeline(this);
-
-    // just a list - *not* ordered.
-    this._timelines = [this._liveTimeline];
-    this._eventIdToTimeline = {};
-
-    this._filter = opts.filter || null;
-}
-utils.inherits(EventTimelineSet, EventEmitter);
-
-/**
- * Get the filter object this timeline set is filtered on, if any
- * @return {?Filter} the optional filter for this timelineSet
- */
-EventTimelineSet.prototype.getFilter = function() {
-    return this._filter;
-};
-
-/**
- * Set the filter object this timeline set is filtered on
- * (passed to the server when paginating via /messages).
- * @param {Filter} filter the filter for this timelineSet
- */
-EventTimelineSet.prototype.setFilter = function(filter) {
-    this._filter = filter;
-};
-
-/**
- * Get the list of pending sent events for this timelineSet's room, filtered
- * by the timelineSet's filter if appropriate.
- *
- * @return {module:models/event.MatrixEvent[]} A list of the sent events
- * waiting for remote echo.
- *
- * @throws If <code>opts.pendingEventOrdering</code> was not 'detached'
- */
-EventTimelineSet.prototype.getPendingEvents = function() {
-    if (!this.room) {
-        return [];
-    }
-
-    if (this._filter) {
-        return this._filter.filterRoomTimeline(this.room.getPendingEvents());
-    }
-    else {
-        return this.room.getPendingEvents();
-    }
-};
-
-/**
- * Get the live timeline for this room.
- *
- * @return {module:models/event-timeline~EventTimeline} live timeline
- */
-EventTimelineSet.prototype.getLiveTimeline = function() {
-    return this._liveTimeline;
-};
-
-/**
- * Return the timeline (if any) this event is in.
- * @param {String} eventId the eventId being sought
- * @return {module:models/event-timeline~EventTimeline} timeline
- */
-EventTimelineSet.prototype.eventIdToTimeline = function(eventId) {
-    return this._eventIdToTimeline[eventId];
-};
-
-/**
- * Track a new event as if it were in the same timeline as an old event,
- * replacing it.
- * @param {String} oldEventId  event ID of the original event
- * @param {String} newEventId  event ID of the replacement event
- */
-EventTimelineSet.prototype.replaceEventId = function(oldEventId, newEventId) {
-    var existingTimeline = this._eventIdToTimeline[oldEventId];
-    if (existingTimeline) {
-        delete this._eventIdToTimeline[oldEventId];
-        this._eventIdToTimeline[newEventId] = existingTimeline;
-    }
-};
-
-/**
- * Reset the live timeline, and start a new one.
- *
- * <p>This is used when /sync returns a 'limited' timeline.
- *
- * @param {string=} backPaginationToken   token for back-paginating the new timeline
- * @param {?bool} flush  Whether to flush the non-live timelines too.
- *
- * @fires module:client~MatrixClient#event:"Room.timelineReset"
- */
-EventTimelineSet.prototype.resetLiveTimeline = function(backPaginationToken, flush) {
-    var newTimeline;
-
-    if (!this._timelineSupport || flush) {
-        // if timeline support is disabled, forget about the old timelines
-        newTimeline = new EventTimeline(this);
-        this._timelines = [newTimeline];
-        this._eventIdToTimeline = {};
-    } else {
-        newTimeline = this.addTimeline();
-    }
-
-    // initialise the state in the new timeline from our last known state
-    var evMap = this._liveTimeline.getState(EventTimeline.FORWARDS).events;
-    var events = [];
-    for (var evtype in evMap) {
-        if (!evMap.hasOwnProperty(evtype)) { continue; }
-        for (var stateKey in evMap[evtype]) {
-            if (!evMap[evtype].hasOwnProperty(stateKey)) { continue; }
-            events.push(evMap[evtype][stateKey]);
-        }
-    }
-    newTimeline.initialiseState(events);
-
-    // make sure we set the pagination token before firing timelineReset,
-    // otherwise clients which start back-paginating will fail, and then get
-    // stuck without realising that they *can* back-paginate.
-    newTimeline.setPaginationToken(backPaginationToken, EventTimeline.BACKWARDS);
-
-    this._liveTimeline = newTimeline;
-    this.emit("Room.timelineReset", this.room, this);
-};
-
-/**
- * Get the timeline which contains the given event, if any
- *
- * @param {string} eventId  event ID to look for
- * @return {?module:models/event-timeline~EventTimeline} timeline containing
- * the given event, or null if unknown
- */
-EventTimelineSet.prototype.getTimelineForEvent = function(eventId) {
-    var res = this._eventIdToTimeline[eventId];
-    return (res === undefined) ? null : res;
-};
-
-/**
- * Get an event which is stored in our timelines
- *
- * @param {string} eventId  event ID to look for
- * @return {?module:models/event~MatrixEvent} the given event, or undefined if unknown
- */
-EventTimelineSet.prototype.findEventById = function(eventId) {
-    var tl = this.getTimelineForEvent(eventId);
-    if (!tl) {
-        return undefined;
-    }
-    return utils.findElement(tl.getEvents(),
-                             function(ev) { return ev.getId() == eventId; });
-};
-
-/**
- * Add a new timeline to this timeline list
- *
- * @return {module:models/event-timeline~EventTimeline} newly-created timeline
- */
-EventTimelineSet.prototype.addTimeline = function() {
-    if (!this._timelineSupport) {
-        throw new Error("timeline support is disabled. Set the 'timelineSupport'" +
-                        " parameter to true when creating MatrixClient to enable" +
-                        " it.");
-    }
-
-    var timeline = new EventTimeline(this);
-    this._timelines.push(timeline);
-    return timeline;
-};
-
-
-/**
- * Add events to a timeline
- *
- * <p>Will fire "Room.timeline" for each event added.
- *
- * @param {MatrixEvent[]} events A list of events to add.
- *
- * @param {boolean} toStartOfTimeline   True to add these events to the start
- * (oldest) instead of the end (newest) of the timeline. If true, the oldest
- * event will be the <b>last</b> element of 'events'.
- *
- * @param {module:models/event-timeline~EventTimeline} timeline   timeline to
- *    add events to.
- *
- * @param {string=} paginationToken   token for the next batch of events
- *
- * @fires module:client~MatrixClient#event:"Room.timeline"
- *
- */
-EventTimelineSet.prototype.addEventsToTimeline = function(events, toStartOfTimeline,
-                                              timeline, paginationToken) {
-    if (!timeline) {
-        throw new Error(
-            "'timeline' not specified for EventTimelineSet.addEventsToTimeline"
-        );
-    }
-
-    if (!toStartOfTimeline && timeline == this._liveTimeline) {
-        throw new Error(
-            "EventTimelineSet.addEventsToTimeline cannot be used for adding events to " +
-            "the live timeline - use Room.addLiveEvents instead"
-        );
-    }
-
-    if (this._filter) {
-        events = this._filter.filterRoomTimeline(events);
-        if (!events.length) {
-            return;
-        }
-    }
-
-    var direction = toStartOfTimeline ? EventTimeline.BACKWARDS :
-        EventTimeline.FORWARDS;
-    var inverseDirection = toStartOfTimeline ? EventTimeline.FORWARDS :
-        EventTimeline.BACKWARDS;
-
-    // Adding events to timelines can be quite complicated. The following
-    // illustrates some of the corner-cases.
-    //
-    // Let's say we start by knowing about four timelines. timeline3 and
-    // timeline4 are neighbours:
-    //
-    //    timeline1    timeline2    timeline3    timeline4
-    //      [M]          [P]          [S] <------> [T]
-    //
-    // Now we paginate timeline1, and get the following events from the server:
-    // [M, N, P, R, S, T, U].
-    //
-    // 1. First, we ignore event M, since we already know about it.
-    //
-    // 2. Next, we append N to timeline 1.
-    //
-    // 3. Next, we don't add event P, since we already know about it,
-    //    but we do link together the timelines. We now have:
-    //
-    //    timeline1    timeline2    timeline3    timeline4
-    //      [M, N] <---> [P]          [S] <------> [T]
-    //
-    // 4. Now we add event R to timeline2:
-    //
-    //    timeline1    timeline2    timeline3    timeline4
-    //      [M, N] <---> [P, R]       [S] <------> [T]
-    //
-    //    Note that we have switched the timeline we are working on from
-    //    timeline1 to timeline2.
-    //
-    // 5. We ignore event S, but again join the timelines:
-    //
-    //    timeline1    timeline2    timeline3    timeline4
-    //      [M, N] <---> [P, R] <---> [S] <------> [T]
-    //
-    // 6. We ignore event T, and the timelines are already joined, so there
-    //    is nothing to do.
-    //
-    // 7. Finally, we add event U to timeline4:
-    //
-    //    timeline1    timeline2    timeline3    timeline4
-    //      [M, N] <---> [P, R] <---> [S] <------> [T, U]
-    //
-    // The important thing to note in the above is what happened when we
-    // already knew about a given event:
-    //
-    //   - if it was appropriate, we joined up the timelines (steps 3, 5).
-    //   - in any case, we started adding further events to the timeline which
-    //       contained the event we knew about (steps 3, 5, 6).
-    //
-    //
-    // So much for adding events to the timeline. But what do we want to do
-    // with the pagination token?
-    //
-    // In the case above, we will be given a pagination token which tells us how to
-    // get events beyond 'U' - in this case, it makes sense to store this
-    // against timeline4. But what if timeline4 already had 'U' and beyond? in
-    // that case, our best bet is to throw away the pagination token we were
-    // given and stick with whatever token timeline4 had previously. In short,
-    // we want to only store the pagination token if the last event we receive
-    // is one we didn't previously know about.
-    //
-    // We make an exception for this if it turns out that we already knew about
-    // *all* of the events, and we weren't able to join up any timelines. When
-    // that happens, it means our existing pagination token is faulty, since it
-    // is only telling us what we already know. Rather than repeatedly
-    // paginating with the same token, we might as well use the new pagination
-    // token in the hope that we eventually work our way out of the mess.
-
-    var didUpdate = false;
-    var lastEventWasNew = false;
-    for (var i = 0; i < events.length; i++) {
-        var event = events[i];
-        var eventId = event.getId();
-
-        var existingTimeline = this._eventIdToTimeline[eventId];
-
-        if (!existingTimeline) {
-            // we don't know about this event yet. Just add it to the timeline.
-            this.addEventToTimeline(event, timeline, toStartOfTimeline);
-            lastEventWasNew = true;
-            didUpdate = true;
-            continue;
-        }
-
-        lastEventWasNew = false;
-
-        if (existingTimeline == timeline) {
-            debuglog("Event " + eventId + " already in timeline " + timeline);
-            continue;
-        }
-
-        var neighbour = timeline.getNeighbouringTimeline(direction);
-        if (neighbour) {
-            // this timeline already has a neighbour in the relevant direction;
-            // let's assume the timelines are already correctly linked up, and
-            // skip over to it.
-            //
-            // there's probably some edge-case here where we end up with an
-            // event which is in a timeline a way down the chain, and there is
-            // a break in the chain somewhere. But I can't really imagine how
-            // that would happen, so I'm going to ignore it for now.
-            //
-            if (existingTimeline == neighbour) {
-                debuglog("Event " + eventId + " in neighbouring timeline - " +
-                            "switching to " + existingTimeline);
-            } else {
-                debuglog("Event " + eventId + " already in a different " +
-                            "timeline " + existingTimeline);
-            }
-            timeline = existingTimeline;
-            continue;
-        }
-
-        // time to join the timelines.
-        console.info("Already have timeline for " + eventId +
-                     " - joining timeline " + timeline + " to " +
-                     existingTimeline);
-        timeline.setNeighbouringTimeline(existingTimeline, direction);
-        existingTimeline.setNeighbouringTimeline(timeline, inverseDirection);
-        timeline = existingTimeline;
-        didUpdate = true;
-    }
-
-    // see above - if the last event was new to us, or if we didn't find any
-    // new information, we update the pagination token for whatever
-    // timeline we ended up on.
-    if (lastEventWasNew || !didUpdate) {
-        timeline.setPaginationToken(paginationToken, direction);
-    }
-};
-
-/**
- * Add an event to the end of this live timeline.
- *
- * @param {MatrixEvent} event Event to be added
- * @param {string?} duplicateStrategy 'ignore' or 'replace'
- */
-EventTimelineSet.prototype.addLiveEvent = function(event, duplicateStrategy) {
-    if (this._filter) {
-        var events = this._filter.filterRoomTimeline([event]);
-        if (!events.length) {
-            return;
-        }
-    }
-
-    var timeline = this._eventIdToTimeline[event.getId()];
-    if (timeline) {
-        if (duplicateStrategy === "replace") {
-            debuglog("EventTimelineSet.addLiveEvent: replacing duplicate event " +
-                     event.getId());
-            var tlEvents = timeline.getEvents();
-            for (var j = 0; j < tlEvents.length; j++) {
-                if (tlEvents[j].getId() === event.getId()) {
-                    // still need to set the right metadata on this event
-                    EventTimeline.setEventMetadata(
-                        event,
-                        timeline.getState(EventTimeline.FORWARDS),
-                        false
-                    );
-
-                    if (!tlEvents[j].encryptedType) {
-                        tlEvents[j] = event;
-                    }
-
-                    // XXX: we need to fire an event when this happens.
-                    break;
-                }
-            }
-        } else {
-            debuglog("EventTimelineSet.addLiveEvent: ignoring duplicate event " +
-                     event.getId());
-        }
-        return;
-    }
-
-    this.addEventToTimeline(event, this._liveTimeline, false);
-};
-
-/**
- * Add event to the given timeline, and emit Room.timeline. Assumes
- * we have already checked we don't know about this event.
- *
- * Will fire "Room.timeline" for each event added.
- *
- * @param {MatrixEvent} event
- * @param {EventTimeline} timeline
- * @param {boolean} toStartOfTimeline
- *
- * @fires module:client~MatrixClient#event:"Room.timeline"
- */
-EventTimelineSet.prototype.addEventToTimeline = function(event, timeline,
-                                                         toStartOfTimeline) {
-    var eventId = event.getId();
-    timeline.addEvent(event, toStartOfTimeline);
-    this._eventIdToTimeline[eventId] = timeline;
-
-    var data = {
-        timeline: timeline,
-        liveEvent: !toStartOfTimeline && timeline == this._liveTimeline,
-    };
-    this.emit("Room.timeline", event, this.room,
-              Boolean(toStartOfTimeline), false, data);
-};
-
-/**
- * Replaces event with ID oldEventId with one with newEventId, if oldEventId is
- * recognised.  Otherwise, add to the live timeline.  Used to handle remote echos.
- *
- * @param {MatrixEvent} localEvent     the new event to be added to the timeline
- * @param {String} oldEventId          the ID of the original event
- * @param {boolean} newEventId         the ID of the replacement event
- *
- * @fires module:client~MatrixClient#event:"Room.timeline"
- */
-EventTimelineSet.prototype.handleRemoteEcho = function(localEvent, oldEventId,
-                                                        newEventId) {
-    // XXX: why don't we infer newEventId from localEvent?
-    var existingTimeline = this._eventIdToTimeline[oldEventId];
-    if (existingTimeline) {
-        delete this._eventIdToTimeline[oldEventId];
-        this._eventIdToTimeline[newEventId] = existingTimeline;
-    } else {
-        if (this._filter) {
-            if (this._filter.filterRoomTimeline([localEvent]).length) {
-                this.addEventToTimeline(localEvent, this._liveTimeline, false);
-            }
-        }
-        else {
-            this.addEventToTimeline(localEvent, this._liveTimeline, false);
-        }
-    }
-};
-
-/**
- * Removes a single event from this room.
- *
- * @param {String} eventId  The id of the event to remove
- *
- * @return {?MatrixEvent} the removed event, or null if the event was not found
- * in this room.
- */
-EventTimelineSet.prototype.removeEvent = function(eventId) {
-    var timeline = this._eventIdToTimeline[eventId];
-    if (!timeline) {
-        return null;
-    }
-
-    var removed = timeline.removeEvent(eventId);
-    if (removed) {
-        delete this._eventIdToTimeline[eventId];
-        var data = {
-            timeline: timeline,
-        };
-        this.emit("Room.timeline", removed, this.room, undefined, true, data);
-    }
-    return removed;
-};
-
-/**
- * Determine where two events appear in the timeline relative to one another
- *
- * @param {string} eventId1   The id of the first event
- * @param {string} eventId2   The id of the second event
-
- * @return {?number} a number less than zero if eventId1 precedes eventId2, and
- *    greater than zero if eventId1 succeeds eventId2. zero if they are the
- *    same event; null if we can't tell (either because we don't know about one
- *    of the events, or because they are in separate timelines which don't join
- *    up).
- */
-EventTimelineSet.prototype.compareEventOrdering = function(eventId1, eventId2) {
-    if (eventId1 == eventId2) {
-        // optimise this case
-        return 0;
-    }
-
-    var timeline1 = this._eventIdToTimeline[eventId1];
-    var timeline2 = this._eventIdToTimeline[eventId2];
-
-    if (timeline1 === undefined) {
-        return null;
-    }
-    if (timeline2 === undefined) {
-        return null;
-    }
-
-    if (timeline1 === timeline2) {
-        // both events are in the same timeline - figure out their
-        // relative indices
-        var idx1, idx2;
-        var events = timeline1.getEvents();
-        for (var idx = 0; idx < events.length &&
-             (idx1 === undefined || idx2 === undefined); idx++) {
-            var evId = events[idx].getId();
-            if (evId == eventId1) {
-                idx1 = idx;
-            }
-            if (evId == eventId2) {
-                idx2 = idx;
-            }
-        }
-        return idx1 - idx2;
-    }
-
-    // the events are in different timelines. Iterate through the
-    // linkedlist to see which comes first.
-
-    // first work forwards from timeline1
-    var tl = timeline1;
-    while (tl) {
-        if (tl === timeline2) {
-            // timeline1 is before timeline2
-            return -1;
-        }
-        tl = tl.getNeighbouringTimeline(EventTimeline.FORWARDS);
-    }
-
-    // now try backwards from timeline1
-    tl = timeline1;
-    while (tl) {
-        if (tl === timeline2) {
-            // timeline2 is before timeline1
-            return 1;
-        }
-        tl = tl.getNeighbouringTimeline(EventTimeline.BACKWARDS);
-    }
-
-    // the timelines are not contiguous.
-    return null;
-};
-
-/**
- * The EventTimelineSet class.
- */
-module.exports = EventTimelineSet;
-
-/**
- * Fires whenever the timeline in a room is updated.
- * @event module:client~MatrixClient#"Room.timeline"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {?Room} room The room, if any, whose timeline was updated.
- * @param {boolean} toStartOfTimeline True if this event was added to the start
- * @param {boolean} removed True if this event has just been removed from the timeline
- * (beginning; oldest) of the timeline e.g. due to pagination.
- *
- * @param {object} data  more data about the event
- *
- * @param {module:event-timeline.EventTimeline} data.timeline the timeline the
- * event was added to/removed from
- *
- * @param {boolean} data.liveEvent true if the event was a real-time event
- * added to the end of the live timeline
- *
- * @example
- * matrixClient.on("Room.timeline",
- *                 function(event, room, toStartOfTimeline, removed, data) {
- *   if (!toStartOfTimeline && data.liveEvent) {
- *     var messageToAppend = room.timeline.[room.timeline.length - 1];
- *   }
- * });
- */
-
-/**
- * Fires whenever the live timeline in a room is reset.
- *
- * When we get a 'limited' sync (for example, after a network outage), we reset
- * the live timeline to be empty before adding the recent events to the new
- * timeline. This event is fired after the timeline is reset, and before the
- * new events are added.
- *
- * @event module:client~MatrixClient#"Room.timelineReset"
- * @param {Room} room The room whose live timeline was reset, if any
- * @param {EventTimelineSet} timelineSet timelineSet room whose live timeline was reset
- */

lib/models/event-timeline.js

@@ -1,338 +0,0 @@
-"use strict";
-
-/**
- * @module models/event-timeline
- */
-
-var RoomState = require("./room-state");
-var utils = require("../utils");
-var MatrixEvent = require("./event").MatrixEvent;
-
-/**
- * Construct a new EventTimeline
- *
- * <p>An EventTimeline represents a contiguous sequence of events in a room.
- *
- * <p>As well as keeping track of the events themselves, it stores the state of
- * the room at the beginning and end of the timeline, and pagination tokens for
- * going backwards and forwards in the timeline.
- *
- * <p>In order that clients can meaningfully maintain an index into a timeline,
- * the EventTimeline object tracks a 'baseIndex'. This starts at zero, but is
- * incremented when events are prepended to the timeline. The index of an event
- * relative to baseIndex therefore remains constant.
- *
- * <p>Once a timeline joins up with its neighbour, they are linked together into a
- * doubly-linked list.
- *
- * @param {EventTimelineSet} eventTimelineSet the set of timelines this is part of
- * @constructor
- */
-function EventTimeline(eventTimelineSet) {
-    this._eventTimelineSet = eventTimelineSet;
-    this._roomId = eventTimelineSet.room ? eventTimelineSet.room.roomId : null;
-    this._events = [];
-    this._baseIndex = 0;
-    this._startState = new RoomState(this._roomId);
-    this._startState.paginationToken = null;
-    this._endState = new RoomState(this._roomId);
-    this._endState.paginationToken = null;
-
-    this._prevTimeline = null;
-    this._nextTimeline = null;
-
-    // this is used by client.js
-    this._paginationRequests = {'b': null, 'f': null};
-
-    this._name = this._roomId + ":" + new Date().toISOString();
-}
-
-/**
- * Symbolic constant for methods which take a 'direction' argument:
- * refers to the start of the timeline, or backwards in time.
- */
-EventTimeline.BACKWARDS = "b";
-
-/**
- * Symbolic constant for methods which take a 'direction' argument:
- * refers to the end of the timeline, or forwards in time.
- */
-EventTimeline.FORWARDS = "f";
-
-/**
- * Initialise the start and end state with the given events
- *
- * <p>This can only be called before any events are added.
- *
- * @param {MatrixEvent[]} stateEvents list of state events to initialise the
- * state with.
- * @throws {Error} if an attempt is made to call this after addEvent is called.
- */
-EventTimeline.prototype.initialiseState = function(stateEvents) {
-    if (this._events.length > 0) {
-        throw new Error("Cannot initialise state after events are added");
-    }
-
-    // we deep-copy the events here, in case they get changed later - we don't
-    // want changes to the start state leaking through to the end state.
-    var oldStateEvents = utils.map(
-        utils.deepCopy(
-            stateEvents.map(function(mxEvent) { return mxEvent.event; })
-        ), function(ev) { return new MatrixEvent(ev); });
-
-    this._startState.setStateEvents(oldStateEvents);
-    this._endState.setStateEvents(stateEvents);
-};
-
-/**
- * Get the ID of the room for this timeline
- * @return {string} room ID
- */
-EventTimeline.prototype.getRoomId = function() {
-    return this._roomId;
-};
-
-/**
- * Get the filter for this timeline's timelineSet (if any)
- * @return {Filter} filter
- */
-EventTimeline.prototype.getFilter = function() {
-    return this._eventTimelineSet.getFilter();
-};
-
-/**
- * Get the timelineSet for this timeline
- * @return {EventTimelineSet} timelineSet
- */
-EventTimeline.prototype.getTimelineSet = function() {
-    return this._eventTimelineSet;
-};
-
-/**
- * Get the base index.
- *
- * <p>This is an index which is incremented when events are prepended to the
- * timeline. An individual event therefore stays at the same index in the array
- * relative to the base index (although note that a given event's index may
- * well be less than the base index, thus giving that event a negative relative
- * index).
- *
- * @return {number}
- */
-EventTimeline.prototype.getBaseIndex = function() {
-    return this._baseIndex;
-};
-
-/**
- * Get the list of events in this context
- *
- * @return {MatrixEvent[]} An array of MatrixEvents
- */
-EventTimeline.prototype.getEvents = function() {
-    return this._events;
-};
-
-/**
- * Get the room state at the start/end of the timeline
- *
- * @param {string} direction   EventTimeline.BACKWARDS to get the state at the
- *   start of the timeline; EventTimeline.FORWARDS to get the state at the end
- *   of the timeline.
- *
- * @return {RoomState} state at the start/end of the timeline
- */
-EventTimeline.prototype.getState = function(direction) {
-    if (direction == EventTimeline.BACKWARDS) {
-        return this._startState;
-    } else if (direction == EventTimeline.FORWARDS) {
-        return this._endState;
-    } else {
-        throw new Error("Invalid direction '" + direction + "'");
-    }
-};
-
-/**
- * Get a pagination token
- *
- * @param {string} direction   EventTimeline.BACKWARDS to get the pagination
- *   token for going backwards in time; EventTimeline.FORWARDS to get the
- *   pagination token for going forwards in time.
- *
- * @return {?string} pagination token
- */
-EventTimeline.prototype.getPaginationToken = function(direction) {
-    return this.getState(direction).paginationToken;
-};
-
-/**
- * Set a pagination token
- *
- * @param {?string} token       pagination token
- *
- * @param {string} direction    EventTimeline.BACKWARDS to set the pagination
- *   token for going backwards in time; EventTimeline.FORWARDS to set the
- *   pagination token for going forwards in time.
- */
-EventTimeline.prototype.setPaginationToken = function(token, direction) {
-    this.getState(direction).paginationToken = token;
-};
-
-/**
- * Get the next timeline in the series
- *
- * @param {string} direction EventTimeline.BACKWARDS to get the previous
- *   timeline; EventTimeline.FORWARDS to get the next timeline.
- *
- * @return {?EventTimeline} previous or following timeline, if they have been
- * joined up.
- */
-EventTimeline.prototype.getNeighbouringTimeline = function(direction) {
-    if (direction == EventTimeline.BACKWARDS) {
-        return this._prevTimeline;
-    } else if (direction == EventTimeline.FORWARDS) {
-        return this._nextTimeline;
-    } else {
-        throw new Error("Invalid direction '" + direction + "'");
-    }
-};
-
-/**
- * Set the next timeline in the series
- *
- * @param {EventTimeline} neighbour previous/following timeline
- *
- * @param {string} direction EventTimeline.BACKWARDS to set the previous
- *   timeline; EventTimeline.FORWARDS to set the next timeline.
- *
- * @throws {Error} if an attempt is made to set the neighbouring timeline when
- * it is already set.
- */
-EventTimeline.prototype.setNeighbouringTimeline = function(neighbour, direction) {
-    if (this.getNeighbouringTimeline(direction)) {
-        throw new Error("timeline already has a neighbouring timeline - " +
-                        "cannot reset neighbour");
-    }
-
-    if (direction == EventTimeline.BACKWARDS) {
-        this._prevTimeline = neighbour;
-    } else if (direction == EventTimeline.FORWARDS) {
-        this._nextTimeline = neighbour;
-    } else {
-        throw new Error("Invalid direction '" + direction + "'");
-    }
-
-    // make sure we don't try to paginate this timeline
-    this.setPaginationToken(null, direction);
-};
-
-/**
- * Add a new event to the timeline, and update the state
- *
- * @param {MatrixEvent} event   new event
- * @param {boolean}  atStart     true to insert new event at the start
- */
-EventTimeline.prototype.addEvent = function(event, atStart) {
-    var stateContext = atStart ? this._startState : this._endState;
-
-    // only call setEventMetadata on the unfiltered timelineSets
-    var timelineSet = this.getTimelineSet();
-    if (timelineSet.room &&
-        timelineSet.room.getUnfilteredTimelineSet() === timelineSet)
-    {
-        EventTimeline.setEventMetadata(event, stateContext, atStart);
-
-        // modify state
-        if (event.isState()) {
-            stateContext.setStateEvents([event]);
-            // it is possible that the act of setting the state event means we
-            // can set more metadata (specifically sender/target props), so try
-            // it again if the prop wasn't previously set. It may also mean that
-            // the sender/target is updated (if the event set was a room member event)
-            // so we want to use the *updated* member (new avatar/name) instead.
-            //
-            // However, we do NOT want to do this on member events if we're going
-            // back in time, else we'll set the .sender value for BEFORE the given
-            // member event, whereas we want to set the .sender value for the ACTUAL
-            // member event itself.
-            if (!event.sender || (event.getType() === "m.room.member" && !atStart)) {
-                EventTimeline.setEventMetadata(event, stateContext, atStart);
-            }
-        }
-    }
-
-    var insertIndex;
-
-    if (atStart) {
-        insertIndex = 0;
-    } else {
-        insertIndex = this._events.length;
-    }
-
-    this._events.splice(insertIndex, 0, event); // insert element
-    if (atStart) {
-        this._baseIndex++;
-    }
-};
-
-/**
- * Static helper method to set sender and target properties
- *
- * @param {MatrixEvent} event   the event whose metadata is to be set
- * @param {RoomState} stateContext  the room state to be queried
- * @param {bool} toStartOfTimeline  if true the event's forwardLooking flag is set false
- */
-EventTimeline.setEventMetadata = function(event, stateContext, toStartOfTimeline) {
-    // set sender and target properties
-    event.sender = stateContext.getSentinelMember(
-        event.getSender()
-    );
-    if (event.getType() === "m.room.member") {
-        event.target = stateContext.getSentinelMember(
-            event.getStateKey()
-        );
-    }
-    if (event.isState()) {
-        // room state has no concept of 'old' or 'current', but we want the
-        // room state to regress back to previous values if toStartOfTimeline
-        // is set, which means inspecting prev_content if it exists. This
-        // is done by toggling the forwardLooking flag.
-        if (toStartOfTimeline) {
-            event.forwardLooking = false;
-        }
-    }
-};
-
-/**
- * Remove an event from the timeline
- *
- * @param {string} eventId  ID of event to be removed
- * @return {?MatrixEvent} removed event, or null if not found
- */
-EventTimeline.prototype.removeEvent = function(eventId) {
-    for (var i = this._events.length - 1; i >= 0; i--) {
-        var ev = this._events[i];
-        if (ev.getId() == eventId) {
-            this._events.splice(i, 1);
-            if (i < this._baseIndex) {
-                this._baseIndex--;
-            }
-            return ev;
-        }
-    }
-    return null;
-};
-
-/**
- * Return a string to identify this timeline, for debugging
- *
- * @return {string} name for this timeline
- */
-EventTimeline.prototype.toString = function() {
-    return this._name;
-};
-
-
-/**
- * The EventTimeline class
- */
-module.exports = EventTimeline;

lib/models/event.js

@@ -1,396 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-
-/**
- * This is an internal module. See {@link MatrixEvent} and {@link RoomEvent} for
- * the public classes.
- * @module models/event
- */
-
-/**
- * Enum for event statuses.
- * @readonly
- * @enum {string}
- */
-module.exports.EventStatus = {
-    /** The event was not sent and will no longer be retried. */
-    NOT_SENT: "not_sent",
-
-    /** The message is being encrypted */
-    ENCRYPTING: "encrypting",
-
-    /** The event is in the process of being sent. */
-    SENDING: "sending",
-    /** The event is in a queue waiting to be sent. */
-    QUEUED: "queued",
-    /** The event has been sent to the server, but we have not yet received the
-     * echo. */
-    SENT: "sent",
-
-    /** The event was cancelled before it was successfully sent. */
-    CANCELLED: "cancelled",
-};
-
-/**
- * Construct a Matrix Event object
- * @constructor
- *
- * @param {Object} event The raw event to be wrapped in this DAO
- *
- * @param {Object=} clearEvent For encrypted events, the plaintext payload for
- * the event (typically containing <tt>type</tt> and <tt>content</tt> fields).
- *
- * @param {Object=} keysProved Keys owned by the sender of this event.
- *    See {@link module:models/event.MatrixEvent#getKeysProved}.
- *
- * @param {Object=} keysClaimed Keys the sender of this event claims.
- *    See {@link module:models/event.MatrixEvent#getKeysClaimed}.
- *
- * @prop {Object} event The raw (possibly encrypted) event. <b>Do not access
- * this property</b> directly unless you absolutely have to. Prefer the getter
- * methods defined on this class. Using the getter methods shields your app
- * from changes to event JSON between Matrix versions.
- *
- * @prop {RoomMember} sender The room member who sent this event, or null e.g.
- * this is a presence event.
- * @prop {RoomMember} target The room member who is the target of this event, e.g.
- * the invitee, the person being banned, etc.
- * @prop {EventStatus} status The sending status of the event.
- * @prop {boolean} forwardLooking True if this event is 'forward looking', meaning
- * that getDirectionalContent() will return event.content and not event.prev_content.
- * Default: true. <strong>This property is experimental and may change.</strong>
- */
-module.exports.MatrixEvent = function MatrixEvent(
-    event, clearEvent, keysProved, keysClaimed
-) {
-    this.event = event || {};
-    this.sender = null;
-    this.target = null;
-    this.status = null;
-    this.forwardLooking = true;
-
-    this._clearEvent = clearEvent || {};
-    this._pushActions = null;
-
-    this._keysProved = keysProved || {};
-    this._keysClaimed = keysClaimed || {};
-};
-
-module.exports.MatrixEvent.prototype = {
-
-    /**
-     * Get the event_id for this event.
-     * @return {string} The event ID, e.g. <code>$143350589368169JsLZx:localhost
-     * </code>
-     */
-    getId: function() {
-        return this.event.event_id;
-    },
-
-    /**
-     * Get the user_id for this event.
-     * @return {string} The user ID, e.g. <code>@alice:matrix.org</code>
-     */
-    getSender: function() {
-        return this.event.sender || this.event.user_id; // v2 / v1
-    },
-
-    /**
-     * Get the (decrypted, if necessary) type of event.
-     *
-     * @return {string} The event type, e.g. <code>m.room.message</code>
-     */
-    getType: function() {
-        return this._clearEvent.type || this.event.type;
-    },
-
-    /**
-     * Get the (possibly encrypted) type of the event that will be sent to the
-     * homeserver.
-     *
-     * @return {string} The event type.
-     */
-    getWireType: function() {
-        return this.event.type;
-    },
-
-    /**
-     * Get the room_id for this event. This will return <code>undefined</code>
-     * for <code>m.presence</code> events.
-     * @return {string} The room ID, e.g. <code>!cURbafjkfsMDVwdRDQ:matrix.org
-     * </code>
-     */
-    getRoomId: function() {
-        return this.event.room_id;
-    },
-
-    /**
-     * Get the timestamp of this event.
-     * @return {Number} The event timestamp, e.g. <code>1433502692297</code>
-     */
-    getTs: function() {
-        return this.event.origin_server_ts;
-    },
-
-    /**
-     * Get the (decrypted, if necessary) event content JSON.
-     *
-     * @return {Object} The event content JSON, or an empty object.
-     */
-    getContent: function() {
-        return this._clearEvent.content || this.event.content || {};
-    },
-
-    /**
-     * Get the (possibly encrypted) event content JSON that will be sent to the
-     * homeserver.
-     *
-     * @return {Object} The event content JSON, or an empty object.
-     */
-    getWireContent: function() {
-        return this.event.content || {};
-    },
-
-    /**
-     * Get the previous event content JSON. This will only return something for
-     * state events which exist in the timeline.
-     * @return {Object} The previous event content JSON, or an empty object.
-     */
-    getPrevContent: function() {
-        // v2 then v1 then default
-        return this.getUnsigned().prev_content || this.event.prev_content || {};
-    },
-
-    /**
-     * Get either 'content' or 'prev_content' depending on if this event is
-     * 'forward-looking' or not. This can be modified via event.forwardLooking.
-     * In practice, this means we get the chronologically earlier content value
-     * for this event (this method should surely be called getEarlierContent)
-     * <strong>This method is experimental and may change.</strong>
-     * @return {Object} event.content if this event is forward-looking, else
-     * event.prev_content.
-     */
-    getDirectionalContent: function() {
-        return this.forwardLooking ? this.getContent() : this.getPrevContent();
-    },
-
-    /**
-     * Get the age of this event. This represents the age of the event when the
-     * event arrived at the device, and not the age of the event when this
-     * function was called.
-     * @return {Number} The age of this event in milliseconds.
-     */
-    getAge: function() {
-        return this.getUnsigned().age || this.event.age; // v2 / v1
-    },
-
-    /**
-     * Get the event state_key if it has one. This will return <code>undefined
-     * </code> for message events.
-     * @return {string} The event's <code>state_key</code>.
-     */
-    getStateKey: function() {
-        return this.event.state_key;
-    },
-
-    /**
-     * Check if this event is a state event.
-     * @return {boolean} True if this is a state event.
-     */
-    isState: function() {
-        return this.event.state_key !== undefined;
-    },
-
-    /**
-     * Replace the content of this event with encrypted versions.
-     * (This is used when sending an event; it should not be used by applications).
-     *
-     * @internal
-     *
-     * @param {string} crypto_type type of the encrypted event - typically
-     * <tt>"m.room.encrypted"</tt>
-     *
-     * @param {object} crypto_content raw 'content' for the encrypted event.
-     * @param {object} keys The local keys claimed and proved by this event.
-     */
-    makeEncrypted: function(crypto_type, crypto_content, keys) {
-        // keep the plain-text data for 'view source'
-        this._clearEvent = {
-            type: this.event.type,
-            content: this.event.content,
-        };
-        this.event.type = crypto_type;
-        this.event.content = crypto_content;
-        this._keysProved = keys;
-        this._keysClaimed = keys;
-    },
-
-    /**
-     * Check if the event is encrypted.
-     * @return {boolean} True if this event is encrypted.
-     */
-    isEncrypted: function() {
-        return Boolean(this._clearEvent.type);
-    },
-
-    /**
-     * The curve25519 key that sent this event
-     * @return {string}
-     */
-    getSenderKey: function() {
-        return this.getKeysProved().curve25519 || null;
-    },
-
-    /**
-     * The keys that must have been owned by the sender of this encrypted event.
-     * <p>
-     * These don't necessarily have to come from this event itself, but may be
-     * implied by the cryptographic session.
-     *
-     * @return {Object<string, string>}
-     */
-    getKeysProved: function() {
-        return this._keysProved;
-    },
-
-    /**
-     * The additional keys the sender of this encrypted event claims to possess.
-     * <p>
-     * These don't necessarily have to come from this event itself, but may be
-     * implied by the cryptographic session.
-     * For example megolm messages don't claim keys directly, but instead
-     * inherit a claim from the olm message that established the session.
-     *
-     * @return {Object<string, string>}
-     */
-    getKeysClaimed: function() {
-        return this._keysClaimed;
-    },
-
-    getUnsigned: function() {
-        return this.event.unsigned || {};
-    },
-
-    /**
-     * Update the content of an event in the same way it would be by the server
-     * if it were redacted before it was sent to us
-     *
-     * @param {module:models/event.MatrixEvent} redaction_event
-     *     event causing the redaction
-     */
-    makeRedacted: function(redaction_event) {
-        // quick sanity-check
-        if (!redaction_event.event) {
-            throw new Error("invalid redaction_event in makeRedacted");
-        }
-
-        // we attempt to replicate what we would see from the server if
-        // the event had been redacted before we saw it.
-        //
-        // The server removes (most of) the content of the event, and adds a
-        // "redacted_because" key to the unsigned section containing the
-        // redacted event.
-        if (!this.event.unsigned) {
-            this.event.unsigned = {};
-        }
-        this.event.unsigned.redacted_because = redaction_event.event;
-
-        var key;
-        for (key in this.event) {
-            if (!this.event.hasOwnProperty(key)) { continue; }
-            if (!_REDACT_KEEP_KEY_MAP[key]) {
-                delete this.event[key];
-            }
-        }
-
-        var keeps = _REDACT_KEEP_CONTENT_MAP[this.getType()] || {};
-        var content = this.getContent();
-        for (key in content) {
-            if (!content.hasOwnProperty(key)) { continue; }
-            if (!keeps[key]) {
-                delete content[key];
-            }
-        }
-    },
-
-    /**
-     * Check if this event has been redacted
-     *
-     * @return {boolean} True if this event has been redacted
-     */
-    isRedacted: function() {
-        return Boolean(this.getUnsigned().redacted_because);
-    },
-
-    /**
-     * Get the push actions, if known, for this event
-     *
-     * @return {?Object} push actions
-     */
-     getPushActions: function() {
-        return this._pushActions;
-     },
-
-    /**
-     * Set the push actions for this event.
-     *
-     * @param {Object} pushActions push actions
-     */
-     setPushActions: function(pushActions) {
-        this._pushActions = pushActions;
-     },
-};
-
-
-/* http://matrix.org/docs/spec/r0.0.1/client_server.html#redactions says:
- *
- * the server should strip off any keys not in the following list:
- *    event_id
- *    type
- *    room_id
- *    user_id
- *    state_key
- *    prev_state
- *    content
- *    [we keep 'unsigned' as well, since that is created by the local server]
- *
- * The content object should also be stripped of all keys, unless it is one of
- * one of the following event types:
- *    m.room.member allows key membership
- *    m.room.create allows key creator
- *    m.room.join_rules allows key join_rule
- *    m.room.power_levels allows keys ban, events, events_default, kick,
- *        redact, state_default, users, users_default.
- *    m.room.aliases allows key aliases
- */
-// a map giving the keys we keep when an event is redacted
-var _REDACT_KEEP_KEY_MAP = [
-    'event_id', 'type', 'room_id', 'user_id', 'state_key', 'prev_state',
-    'content', 'unsigned',
-].reduce(function(ret, val) { ret[val] = 1; return ret; }, {});
-
-// a map from event type to the .content keys we keep when an event is redacted
-var _REDACT_KEEP_CONTENT_MAP = {
-    'm.room.member': {'membership': 1},
-    'm.room.create': {'creator': 1},
-    'm.room.join_rules': {'join_rule': 1},
-    'm.room.power_levels': {'ban': 1, 'events': 1, 'events_default': 1,
-                            'kick': 1, 'redact': 1, 'state_default': 1,
-                            'users': 1, 'users_default': 1,
-                           },
-    'm.room.aliases': {'aliases': 1},
-};

lib/models/room-member.js

@@ -1,285 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * @module models/room-member
- */
-var EventEmitter = require("events").EventEmitter;
-var ContentRepo = require("../content-repo");
-
-var utils = require("../utils");
-
-/**
- * Construct a new room member.
- *
- * @constructor
- * @alias module:models/room-member
- *
- * @param {string} roomId The room ID of the member.
- * @param {string} userId The user ID of the member.
- * @prop {string} roomId The room ID for this member.
- * @prop {string} userId The user ID of this member.
- * @prop {boolean} typing True if the room member is currently typing.
- * @prop {string} name The human-readable name for this room member.
- * @prop {Number} powerLevel The power level for this room member.
- * @prop {Number} powerLevelNorm The normalised power level (0-100) for this
- * room member.
- * @prop {User} user The User object for this room member, if one exists.
- * @prop {string} membership The membership state for this room member e.g. 'join'.
- * @prop {Object} events The events describing this RoomMember.
- * @prop {MatrixEvent} events.member The m.room.member event for this RoomMember.
- */
-function RoomMember(roomId, userId) {
-    this.roomId = roomId;
-    this.userId = userId;
-    this.typing = false;
-    this.name = userId;
-    this.powerLevel = 0;
-    this.powerLevelNorm = 0;
-    this.user = null;
-    this.membership = null;
-    this.events = {
-        member: null
-    };
-    this._updateModifiedTime();
-}
-utils.inherits(RoomMember, EventEmitter);
-
-/**
- * Update this room member's membership event. May fire "RoomMember.name" if
- * this event updates this member's name.
- * @param {MatrixEvent} event The <code>m.room.member</code> event
- * @param {RoomState} roomState Optional. The room state to take into account
- * when calculating (e.g. for disambiguating users with the same name).
- * @fires module:client~MatrixClient#event:"RoomMember.name"
- * @fires module:client~MatrixClient#event:"RoomMember.membership"
- */
-RoomMember.prototype.setMembershipEvent = function(event, roomState) {
-    if (event.getType() !== "m.room.member") {
-        return;
-    }
-    this.events.member = event;
-
-    var oldMembership = this.membership;
-    this.membership = event.getDirectionalContent().membership;
-
-    var oldName = this.name;
-    this.name = calculateDisplayName(this, event, roomState);
-    if (oldMembership !== this.membership) {
-        this._updateModifiedTime();
-        this.emit("RoomMember.membership", event, this, oldMembership);
-    }
-    if (oldName !== this.name) {
-        this._updateModifiedTime();
-        this.emit("RoomMember.name", event, this, oldName);
-    }
-};
-
-/**
- * Update this room member's power level event. May fire
- * "RoomMember.powerLevel" if this event updates this member's power levels.
- * @param {MatrixEvent} powerLevelEvent The <code>m.room.power_levels</code>
- * event
- * @fires module:client~MatrixClient#event:"RoomMember.powerLevel"
- */
-RoomMember.prototype.setPowerLevelEvent = function(powerLevelEvent) {
-    if (powerLevelEvent.getType() !== "m.room.power_levels") {
-        return;
-    }
-    var maxLevel = powerLevelEvent.getContent().users_default || 0;
-    utils.forEach(utils.values(powerLevelEvent.getContent().users), function(lvl) {
-        maxLevel = Math.max(maxLevel, lvl);
-    });
-    var oldPowerLevel = this.powerLevel;
-    var oldPowerLevelNorm = this.powerLevelNorm;
-
-    if (powerLevelEvent.getContent().users[this.userId] !== undefined) {
-        this.powerLevel = powerLevelEvent.getContent().users[this.userId];
-    } else if (powerLevelEvent.getContent().users_default !== undefined) {
-        this.powerLevel = powerLevelEvent.getContent().users_default;
-    } else {
-        this.powerLevel = 0;
-    }
-    this.powerLevelNorm = 0;
-    if (maxLevel > 0) {
-        this.powerLevelNorm = (this.powerLevel * 100) / maxLevel;
-    }
-
-    // emit for changes in powerLevelNorm as well (since the app will need to
-    // redraw everyone's level if the max has changed)
-    if (oldPowerLevel !== this.powerLevel || oldPowerLevelNorm !== this.powerLevelNorm) {
-        this._updateModifiedTime();
-        this.emit("RoomMember.powerLevel", powerLevelEvent, this);
-    }
-};
-
-/**
- * Update this room member's typing event. May fire "RoomMember.typing" if
- * this event changes this member's typing state.
- * @param {MatrixEvent} event The typing event
- * @fires module:client~MatrixClient#event:"RoomMember.typing"
- */
-RoomMember.prototype.setTypingEvent = function(event) {
-    if (event.getType() !== "m.typing") {
-        return;
-    }
-    var oldTyping = this.typing;
-    this.typing = false;
-    var typingList = event.getContent().user_ids;
-    if (!utils.isArray(typingList)) {
-        // malformed event :/ bail early. TODO: whine?
-        return;
-    }
-    if (typingList.indexOf(this.userId) !== -1) {
-        this.typing = true;
-    }
-    if (oldTyping !== this.typing) {
-        this._updateModifiedTime();
-        this.emit("RoomMember.typing", event, this);
-    }
-};
-
-/**
- * Update the last modified time to the current time.
- */
-RoomMember.prototype._updateModifiedTime = function() {
-    this._modified = Date.now();
-};
-
-/**
- * Get the timestamp when this RoomMember was last updated. This timestamp is
- * updated when properties on this RoomMember are updated.
- * It is updated <i>before</i> firing events.
- * @return {number} The timestamp
- */
-RoomMember.prototype.getLastModifiedTime = function() {
-    return this._modified;
-};
-
-/**
- * Get the avatar URL for a room member.
- * @param {string} baseUrl The base homeserver URL See
- * {@link module:client~MatrixClient#getHomeserverUrl}.
- * @param {Number} width The desired width of the thumbnail.
- * @param {Number} height The desired height of the thumbnail.
- * @param {string} resizeMethod The thumbnail resize method to use, either
- * "crop" or "scale".
- * @param {Boolean} allowDefault (optional) Passing false causes this method to
- * return null if the user has no avatar image. Otherwise, a default image URL
- * will be returned. Default: true.
- * @param {Boolean} allowDirectLinks (optional) If true, the avatar URL will be
- * returned even if it is a direct hyperlink rather than a matrix content URL.
- * If false, any non-matrix content URLs will be ignored. Setting this option to
- * true will expose URLs that, if fetched, will leak information about the user
- * to anyone who they share a room with.
- * @return {?string} the avatar URL or null.
- */
-RoomMember.prototype.getAvatarUrl =
-        function(baseUrl, width, height, resizeMethod, allowDefault, allowDirectLinks) {
-    if (allowDefault === undefined) { allowDefault = true; }
-    if (!this.events.member && !allowDefault) {
-        return null;
-    }
-    var rawUrl = this.events.member ? this.events.member.getContent().avatar_url : null;
-    var httpUrl = ContentRepo.getHttpUriForMxc(
-        baseUrl, rawUrl, width, height, resizeMethod, allowDirectLinks
-    );
-    if (httpUrl) {
-        return httpUrl;
-    }
-    else if (allowDefault) {
-        return ContentRepo.getIdenticonUri(
-            baseUrl, this.userId, width, height
-        );
-    }
-    return null;
-};
-
-function calculateDisplayName(member, event, roomState) {
-    var displayName = event.getDirectionalContent().displayname;
-    var selfUserId = member.userId;
-
-    if (!displayName) {
-        return selfUserId;
-    }
-
-    if (!roomState) {
-        return displayName;
-    }
-
-    var userIds = roomState.getUserIdsWithDisplayName(displayName);
-    var otherUsers = userIds.filter(function(u) {
-        return u !== selfUserId;
-    });
-    if (otherUsers.length > 0) {
-        return displayName + " (" + selfUserId + ")";
-    }
-    return displayName;
-}
-
-/**
- * The RoomMember class.
- */
-module.exports = RoomMember;
-
-/**
- * Fires whenever any room member's name changes.
- * @event module:client~MatrixClient#"RoomMember.name"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.name changed.
- * @param {string?} oldName The previous name. Null if the member didn't have a
- *    name previously.
- * @example
- * matrixClient.on("RoomMember.name", function(event, member){
- *   var newName = member.name;
- * });
- */
-
-/**
- * Fires whenever any room member's membership state changes.
- * @event module:client~MatrixClient#"RoomMember.membership"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.membership changed.
- * @param {string?} oldMembership The previous membership state. Null if it's a
- *    new member.
- * @example
- * matrixClient.on("RoomMember.membership", function(event, member, oldMembership){
- *   var newState = member.membership;
- * });
- */
-
-/**
- * Fires whenever any room member's typing state changes.
- * @event module:client~MatrixClient#"RoomMember.typing"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.typing changed.
- * @example
- * matrixClient.on("RoomMember.typing", function(event, member){
- *   var isTyping = member.typing;
- * });
- */
-
-/**
- * Fires whenever any room member's power level changes.
- * @event module:client~MatrixClient#"RoomMember.powerLevel"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomMember} member The member whose RoomMember.powerLevel changed.
- * @example
- * matrixClient.on("RoomMember.powerLevel", function(event, member){
- *   var newPowerLevel = member.powerLevel;
- *   var newNormPowerLevel = member.powerLevelNorm;
- * });
- */

lib/models/room-state.js

@@ -1,432 +0,0 @@
-/*
-Copyright 2015, 2016 OpenMarket Ltd
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-*/
-"use strict";
-/**
- * @module models/room-state
- */
-var EventEmitter = require("events").EventEmitter;
-
-var utils = require("../utils");
-var RoomMember = require("./room-member");
-
-/**
- * Construct room state.
- * @constructor
- * @param {?string} roomId Optional. The ID of the room which has this state.
- * If none is specified it just tracks paginationTokens, useful for notifTimelineSet
- * @prop {Object.<string, RoomMember>} members The room member dictionary, keyed
- * on the user's ID.
- * @prop {Object.<string, Object.<string, MatrixEvent>>} events The state
- * events dictionary, keyed on the event type and then the state_key value.
- * @prop {string} paginationToken The pagination token for this state.
- */
-function RoomState(roomId) {
-    this.roomId = roomId;
-    this.members = {
-        // userId: RoomMember
-    };
-    this.events = {
-        // eventType: { stateKey: MatrixEvent }
-    };
-    this.paginationToken = null;
-
-    this._sentinels = {
-        // userId: RoomMember
-    };
-    this._updateModifiedTime();
-    this._displayNameToUserIds = {};
-    this._userIdsToDisplayNames = {};
-    this._tokenToInvite = {}; // 3pid invite state_key to m.room.member invite
-}
-utils.inherits(RoomState, EventEmitter);
-
-/**
- * Get all RoomMembers in this room.
- * @return {Array<RoomMember>} A list of RoomMembers.
- */
-RoomState.prototype.getMembers = function() {
-    return utils.values(this.members);
-};
-
-/**
- * Get a room member by their user ID.
- * @param {string} userId The room member's user ID.
- * @return {RoomMember} The member or null if they do not exist.
- */
-RoomState.prototype.getMember = function(userId) {
-    return this.members[userId] || null;
-};
-
-/**
- * Get a room member whose properties will not change with this room state. You
- * typically want this if you want to attach a RoomMember to a MatrixEvent which
- * may no longer be represented correctly by Room.currentState or Room.oldState.
- * The term 'sentinel' refers to the fact that this RoomMember is an unchanging
- * guardian for state at this particular point in time.
- * @param {string} userId The room member's user ID.
- * @return {RoomMember} The member or null if they do not exist.
- */
-RoomState.prototype.getSentinelMember = function(userId) {
-    return this._sentinels[userId] || null;
-};
-
-/**
- * Get state events from the state of the room.
- * @param {string} eventType The event type of the state event.
- * @param {string} stateKey Optional. The state_key of the state event. If
- * this is <code>undefined</code> then all matching state events will be
- * returned.
- * @return {MatrixEvent[]|MatrixEvent} A list of events if state_key was
- * <code>undefined</code>, else a single event (or null if no match found).
- */
-RoomState.prototype.getStateEvents = function(eventType, stateKey) {
-    if (!this.events[eventType]) {
-        // no match
-        return stateKey === undefined ? [] : null;
-    }
-    if (stateKey === undefined) { // return all values
-        return utils.values(this.events[eventType]);
-    }
-    var event = this.events[eventType][stateKey];
-    return event ? event : null;
-};
-
-/**
- * Add an array of one or more state MatrixEvents, overwriting
- * any existing state with the same {type, stateKey} tuple. Will fire
- * "RoomState.events" for every event added. May fire "RoomState.members"
- * if there are <code>m.room.member</code> events.
- * @param {MatrixEvent[]} stateEvents a list of state events for this room.
- * @fires module:client~MatrixClient#event:"RoomState.members"
- * @fires module:client~MatrixClient#event:"RoomState.newMember"
- * @fires module:client~MatrixClient#event:"RoomState.events"
- */
-RoomState.prototype.setStateEvents = function(stateEvents) {
-    var self = this;
-    this._updateModifiedTime();
-
-    // update the core event dict
-    utils.forEach(stateEvents, function(event) {
-        if (event.getRoomId() !== self.roomId) { return; }
-        if (!event.isState()) { return; }
-
-        if (self.events[event.getType()] === undefined) {
-            self.events[event.getType()] = {};
-        }
-        self.events[event.getType()][event.getStateKey()] = event;
-        if (event.getType() === "m.room.member") {
-            _updateDisplayNameCache(
-                self, event.getStateKey(), event.getContent().displayname
-            );
-            _updateThirdPartyTokenCache(self, event);
-        }
-        self.emit("RoomState.events", event, self);
-    });
-
-    // update higher level data structures. This needs to be done AFTER the
-    // core event dict as these structures may depend on other state events in
-    // the given array (e.g. disambiguating display names in one go to do both
-    // clashing names rather than progressively which only catches 1 of them).
-    utils.forEach(stateEvents, function(event) {
-        if (event.getRoomId() !== self.roomId) { return; }
-        if (!event.isState()) { return; }
-
-        if (event.getType() === "m.room.member") {
-            var userId = event.getStateKey();
-
-            // leave events apparently elide the displayname or avatar_url,
-            // so let's fake one up so that we don't leak user ids
-            // into the timeline
-            if (event.getContent().membership === "leave" ||
-                event.getContent().membership === "ban")
-            {
-                event.getContent().avatar_url =
-                    event.getContent().avatar_url ||
-                    event.getPrevContent().avatar_url;
-                event.getContent().displayname =
-                    event.getContent().displayname ||
-                    event.getPrevContent().displayname;
-            }
-
-            var member = self.members[userId];
-            if (!member) {
-                member = new RoomMember(event.getRoomId(), userId);
-                self.emit("RoomState.newMember", event, self, member);
-            }
-            // Add a new sentinel for this change. We apply the same
-            // operations to both sentinel and member rather than deep copying
-            // so we don't make assumptions about the properties of RoomMember
-            // (e.g. and manage to break it because deep copying doesn't do
-            // everything).
-            var sentinel = new RoomMember(event.getRoomId(), userId);
-            utils.forEach([member, sentinel], function(roomMember) {
-                roomMember.setMembershipEvent(event, self);
-                // this member may have a power level already, so set it.
-                var pwrLvlEvent = self.getStateEvents("m.room.power_levels", "");
-                if (pwrLvlEvent) {
-                    roomMember.setPowerLevelEvent(pwrLvlEvent);
-                }
-            });
-
-            self._sentinels[userId] = sentinel;
-            self.members[userId] = member;
-            self.emit("RoomState.members", event, self, member);
-        }
-        else if (event.getType() === "m.room.power_levels") {
-            var members = utils.values(self.members);
-            utils.forEach(members, function(member) {
-                member.setPowerLevelEvent(event);
-                self.emit("RoomState.members", event, self, member);
-            });
-        }
-    });
-};
-
-/**
- * Set the current typing event for this room.
- * @param {MatrixEvent} event The typing event
- */
-RoomState.prototype.setTypingEvent = function(event) {
-    utils.forEach(utils.values(this.members), function(member) {
-        member.setTypingEvent(event);
-    });
-};
-
-/**
- * Get the m.room.member event which has the given third party invite token.
- *
- * @param {string} token The token
- * @return {?MatrixEvent} The m.room.member event or null
- */
-RoomState.prototype.getInviteForThreePidToken = function(token) {
-    return this._tokenToInvite[token] || null;
-};
-
-/**
- * Update the last modified time to the current time.
- */
-RoomState.prototype._updateModifiedTime = function() {
-    this._modified = Date.now();
-};
-
-/**
- * Get the timestamp when this room state was last updated. This timestamp is
- * updated when this object has received new state events.
- * @return {number} The timestamp
- */
-RoomState.prototype.getLastModifiedTime = function() {
-    return this._modified;
-};
-
-/**
- * Get user IDs with the specified display name.
- * @param {string} displayName The display name to get user IDs from.
- * @return {string[]} An array of user IDs or an empty array.
- */
-RoomState.prototype.getUserIdsWithDisplayName = function(displayName) {
-    return this._displayNameToUserIds[displayName] || [];
-};
-
-/**
- * Short-form for maySendEvent('m.room.message', userId)
- * @param {string} userId The user ID of the user to test permission for
- * @return {boolean} true if the given user ID should be permitted to send
- *                   message events into the given room.
- */
-RoomState.prototype.maySendMessage = function(userId) {
-    return this._maySendEventOfType('m.room.message', userId, false);
-};
-
-/**
- * Returns true if the given user ID has permission to send a normal
- * event of type `eventType` into this room.
- * @param {string} type The type of event to test
- * @param {string} userId The user ID of the user to test permission for
- * @return {boolean} true if the given user ID should be permitted to send
- *                        the given type of event into this room,
- *                        according to the room's state.
- */
-RoomState.prototype.maySendEvent = function(eventType, userId) {
-    return this._maySendEventOfType(eventType, userId, false);
-};
-
-
-/**
- * Returns true if the given MatrixClient has permission to send a state
- * event of type `stateEventType` into this room.
- * @param {string} type The type of state events to test
- * @param {MatrixClient}  The client to test permission for
- * @return {boolean} true if the given client should be permitted to send
- *                        the given type of state event into this room,
- *                        according to the room's state.
- */
-RoomState.prototype.mayClientSendStateEvent = function(stateEventType, cli) {
-    if (cli.isGuest()) {
-        return false;
-    }
-    return this.maySendStateEvent(stateEventType, cli.credentials.userId);
-};
-
-/**
- * Returns true if the given user ID has permission to send a state
- * event of type `stateEventType` into this room.
- * @param {string} type The type of state events to test
- * @param {string} userId The user ID of the user to test permission for
- * @return {boolean} true if the given user ID should be permitted to send
- *                        the given type of state event into this room,
- *                        according to the room's state.
- */
-RoomState.prototype.maySendStateEvent = function(stateEventType, userId) {
-    return this._maySendEventOfType(stateEventType, userId, true);
-};
-
-/**
- * Returns true if the given user ID has permission to send a normal or state
- * event of type `eventType` into this room.
- * @param {string} type The type of event to test
- * @param {string} userId The user ID of the user to test permission for
- * @param {boolean} state If true, tests if the user may send a state
-                          event of this type. Otherwise tests whether
-                          they may send a regular event.
- * @return {boolean} true if the given user ID should be permitted to send
- *                        the given type of event into this room,
- *                        according to the room's state.
- */
-RoomState.prototype._maySendEventOfType = function(eventType, userId, state) {
-    var member = this.getMember(userId);
-    if (!member || member.membership == 'leave') { return false; }
-
-    var power_levels_event = this.getStateEvents('m.room.power_levels', '');
-
-    var power_levels;
-    var events_levels = {};
-
-    var default_user_level = 0;
-    var user_levels = [];
-
-    var state_default = 0;
-    var events_default = 0;
-    if (power_levels_event) {
-        power_levels = power_levels_event.getContent();
-        events_levels = power_levels.events || {};
-
-        default_user_level = parseInt(power_levels.users_default || 0);
-        user_levels = power_levels.users || {};
-
-        if (power_levels.state_default !== undefined) {
-            state_default = power_levels.state_default;
-        } else {
-            state_default = 50;
-        }
-        if (power_levels.events_default !== undefined) {
-            events_default = power_levels.events_default;
-        }
-    }
-
-    var required_level = state ? state_default : events_default;
-    if (events_levels[eventType] !== undefined) {
-        required_level = events_levels[eventType];
-    }
-    return member.powerLevel >= required_level;
-};
-
-/**
- * The RoomState class.
- */
-module.exports = RoomState;
-
-
-function _updateThirdPartyTokenCache(roomState, memberEvent) {
-    if (!memberEvent.getContent().third_party_invite) {
-        return;
-    }
-    var token = (memberEvent.getContent().third_party_invite.signed || {}).token;
-    if (!token) {
-        return;
-    }
-    var threePidInvite = roomState.getStateEvents(
-        "m.room.third_party_invite", token
-    );
-    if (!threePidInvite) {
-        return;
-    }
-    roomState._tokenToInvite[token] = memberEvent;
-}
-
-function _updateDisplayNameCache(roomState, userId, displayName) {
-    var oldName = roomState._userIdsToDisplayNames[userId];
-    delete roomState._userIdsToDisplayNames[userId];
-    if (oldName) {
-        // Remove the old name from the cache.
-        // We clobber the user_id > name lookup but the name -> [user_id] lookup
-        // means we need to remove that user ID from that array rather than nuking
-        // the lot.
-        var existingUserIds = roomState._displayNameToUserIds[oldName] || [];
-        for (var i = 0; i < existingUserIds.length; i++) {
-            if (existingUserIds[i] === userId) {
-                // remove this user ID from this array
-                existingUserIds.splice(i, 1);
-                i--;
-            }
-        }
-        roomState._displayNameToUserIds[oldName] = existingUserIds;
-    }
-
-    roomState._userIdsToDisplayNames[userId] = displayName;
-    if (!roomState._displayNameToUserIds[displayName]) {
-        roomState._displayNameToUserIds[displayName] = [];
-    }
-    roomState._displayNameToUserIds[displayName].push(userId);
-}
-
-/**
- * Fires whenever the event dictionary in room state is updated.
- * @event module:client~MatrixClient#"RoomState.events"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.events dictionary
- * was updated.
- * @example
- * matrixClient.on("RoomState.events", function(event, state){
- *   var newStateEvent = event;
- * });
- */
-
-/**
- * Fires whenever a member in the members dictionary is updated in any way.
- * @event module:client~MatrixClient#"RoomState.members"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.members dictionary
- * was updated.
- * @param {RoomMember} member The room member that was updated.
- * @example
- * matrixClient.on("RoomState.members", function(event, state, member){
- *   var newMembershipState = member.membership;
- * });
- */
-
- /**
- * Fires whenever a member is added to the members dictionary. The RoomMember
- * will not be fully populated yet (e.g. no membership state).
- * @event module:client~MatrixClient#"RoomState.newMember"
- * @param {MatrixEvent} event The matrix event which caused this event to fire.
- * @param {RoomState} state The room state whose RoomState.members dictionary
- * was updated with a new entry.
- * @param {RoomMember} member The room member that was added.
- * @example
- * matrixClient.on("RoomState.newMember", function(event, state, member){
- *   // add event listeners on 'member'
- * });
- */