Add build output to repo

Author: thoraj

.gitignore

@@ -1,6 +1,5 @@
 # Custom
 .idea/
-lib/
 .npmrc
 
 # Logs

lib/ModuleApi.d.ts

@@ -0,0 +1,132 @@
+import React from "react";
+import { PlainSubstitution, TranslationStringsObject } from "./types/translations";
+import { DialogContent, DialogProps } from "./components/DialogContent";
+import { AccountAuthInfo } from "./types/AccountAuthInfo";
+import { ModuleUiDialogOptions } from "./types/ModuleUiDialogOptions";
+import { App } from "./types/App";
+import { Container } from "./types/Container";
+/**
+ * A module API surface for the react-sdk. Provides a stable API for modules to
+ * interact with the internals of the react-sdk without having to update themselves
+ * for refactorings or code changes within the react-sdk.
+ *
+ * An instance of a ModuleApi is provided to all modules at runtime.
+ */
+export interface ModuleApi {
+    /**
+     * Register strings with the translation engine. This supports overriding strings which
+     * the system is already aware of.
+     * @param translations The translations to load.
+     */
+    registerTranslations(translations: TranslationStringsObject): void;
+    /**
+     * Runs a string through the translation engine. If variables are needed, use %(varName)s
+     * as a placeholder for varName in the variables object.
+     * @param s The string. Should already be known to the engine.
+     * @param variables The variables to replace, if any.
+     * @returns The translated string.
+     */
+    translateString(s: string, variables?: Record<string, PlainSubstitution>): string;
+    /**
+     * Opens a dialog in the client.
+     * @param initialTitleOrOptions Initial options for the dialog. Can be the title of the dialog, or a
+     *                              configuration object. Note that the dialog implementation may later
+     *                              modify its own options via the {@link DialogProps.setOptions} callback.
+     * @param body The function which creates a body component for the dialog.
+     * @param props Optional props to provide to {@link body}, in addition to the common set in {@link DialogProps}.
+     * @returns Whether the user submitted the dialog or closed it, and the model returned by the
+     * dialog component if submitted.
+     */
+    openDialog<M extends object, P extends DialogProps = DialogProps, C extends DialogContent<P> = DialogContent<P>>(initialTitleOrOptions: string | ModuleUiDialogOptions, body: (props: P, ref: React.RefObject<C>) => React.ReactNode, props?: Omit<P, keyof DialogProps>): Promise<{
+        didOkOrSubmit: boolean;
+        model: M;
+    }>;
+    /**
+     * Registers for an account on the currently connected homeserver. This requires that the homeserver
+     * offer a password-only flow without other flows. This means it is not traditionally compatible with
+     * homeservers like matrix.org which also generally require a combination of reCAPTCHA, email address,
+     * terms of service acceptance, etc.
+     * @param username The username to register.
+     * @param password The password to register.
+     * @param displayName Optional display name to set.
+     * @returns Resolves to the authentication info for the created account.
+     */
+    registerSimpleAccount(username: string, password: string, displayName?: string): Promise<AccountAuthInfo>;
+    /**
+     * Switches the user's currently logged-in account to the one specified. The user will not
+     * be warned.
+     * @param accountAuthInfo The authentication info to log in with.
+     * @returns Resolves when complete.
+     */
+    overwriteAccountAuth(accountAuthInfo: AccountAuthInfo): Promise<void>;
+    /**
+     * Switches the user's current view to look at the given permalink. If the permalink is
+     * a room, it can optionally be joined automatically if required.
+     *
+     * Permalink must be a matrix.to permalink at this time.
+     * @param uri The URI to navigate to.
+     * @param andJoin True to also join the room if needed. Does nothing if the link isn't to
+     * a room.
+     * @returns Resolves when complete.
+     */
+    navigatePermalink(uri: string, andJoin?: boolean): Promise<void>;
+    /**
+     * Gets a value verbatim from the config. The returned value will be of the type specified
+     * by the user - it is not verified against a schema. If the value does not exist in the
+     * config then this will return undefined;
+     *
+     * The caller should provide a namespace which it owns to retrieve settings from. During
+     * read, the `key` will be treated as a sub-key of the namespace on the overall configuration
+     * object. For example:
+     *
+     * ```json
+     * {
+     *     "inaccessible_root_level_config": "hello world",
+     *     "org.example.my_module_namespace": {
+     *         "my_key": 42
+     *     }
+     * }
+     * ```
+     *
+     * The caller would use `getConfigValue<number>("org.example.my_module_namespace", "my_key")`
+     * to get the targeted config value.
+     *
+     * There is no root namespace, thus root-level config values cannot be read.
+     * @param namespace The module's namespace.
+     * @param key The key to look up.
+     * @returns The config value verbatim.
+     */
+    getConfigValue<T>(namespace: string, key: string): T | undefined;
+    /**
+     * Gets the apps for a given room.
+     *
+     * @param roomId The room ID to get the apps for.
+     * @returns The apps for the given room.
+     */
+    getApps(roomId: string): Array<App>;
+    /**
+     * Gets the avatar URL for an app.
+     *
+     * @param app The app to get the avatar URL for.
+     * @param width The width of the avatar.
+     * @param height The height of the avatar.
+     * @param resizeMethod The resize method to use, either "crop" or "scale".
+     */
+    getAppAvatarUrl(app: App, width?: number, height?: number, resizeMethod?: string): string | null;
+    /**
+     * Checks if an app is in a container for a given room.
+     *
+     * @param app The app to check.
+     * @param container The container to check.
+     * @param roomId The room ID to check.
+     */
+    isAppInContainer(app: App, container: Container, roomId: string): boolean;
+    /**
+     * Moves apps to containers for a given room.
+     *
+     * @param app The app to move.
+     * @param container The container to move the app to.
+     * @param roomId The room ID to move the app in.
+     */
+    moveAppToContainer(app: App, container: Container, roomId: string): void;
+}

lib/ModuleApi.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

lib/RuntimeModule.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { ModuleApi } from "./ModuleApi";
+import { PlainSubstitution } from "./types/translations";
+import { AllExtensions } from "./types/extensions";
+/**
+ * Represents a module which is loaded at runtime. Modules which implement this class
+ * will be provided information about the application state and can react to it.
+ */
+export declare abstract class RuntimeModule extends EventEmitter {
+    protected readonly moduleApi: ModuleApi;
+    extensions?: AllExtensions;
+    moduleName: string;
+    protected constructor(moduleApi: ModuleApi);
+    /**
+     * Run a string through the translation engine. Shortcut to ModuleApi#translateString().
+     * @param s The string.
+     * @param variables The variables, if any.
+     * @returns The translated string.
+     * @protected
+     */
+    protected t(s: string, variables?: Record<string, PlainSubstitution>): string;
+}

lib/RuntimeModule.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RuntimeModule = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _events = require("events");
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+// TODO: Type the event emitter with AnyLifecycle (extract TypedEventEmitter from js-sdk somehow?)
+// See https://github.com/matrix-org/matrix-react-sdk-module-api/issues/4
+
+/**
+ * Represents a module which is loaded at runtime. Modules which implement this class
+ * will be provided information about the application state and can react to it.
+ */
+var RuntimeModule = /*#__PURE__*/function (_EventEmitter) {
+  (0, _inherits2["default"])(RuntimeModule, _EventEmitter);
+
+  var _super = _createSuper(RuntimeModule);
+
+  function RuntimeModule(moduleApi) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, RuntimeModule);
+    _this = _super.call(this);
+    _this.moduleApi = moduleApi;
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "extensions", void 0);
+    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "moduleName", RuntimeModule.name);
+    return _this;
+  }
+  /**
+   * Run a string through the translation engine. Shortcut to ModuleApi#translateString().
+   * @param s The string.
+   * @param variables The variables, if any.
+   * @returns The translated string.
+   * @protected
+   */
+
+
+  (0, _createClass2["default"])(RuntimeModule, [{
+    key: "t",
+    value: function t(s, variables) {
+      return this.moduleApi.translateString(s, variables);
+    }
+  }]);
+  return RuntimeModule;
+}(_events.EventEmitter);
+
+exports.RuntimeModule = RuntimeModule;

lib/components/DialogContent.d.ts

@@ -0,0 +1,56 @@
+import * as React from "react";
+import { ModuleApi } from "../ModuleApi";
+import { PlainSubstitution } from "../types/translations";
+import { ModuleUiDialogOptions } from "../types/ModuleUiDialogOptions";
+/** React properties for dialog content implementations based on {@link DialogContent} */
+export interface DialogProps {
+    /**
+     * A reference to the active Module API.
+     */
+    moduleApi: ModuleApi;
+    /**
+     * Callback to update the dialog options.
+     *
+     * Dialog content implementations can call this to update any of the options that were
+     * originally set via {@link ModuleApi.openDialog}.
+     *
+     * @param options - The updates that should be applied to the dialog options. Any properties
+     * not set in the {@link options} are left unchanged.
+     */
+    setOptions(options: Partial<ModuleUiDialogOptions>): void;
+    /**
+     * Cancel the dialog programmatically.
+     */
+    cancel(): void;
+}
+/** State of {@link DialogContent} */
+export interface DialogState {
+    busy: boolean;
+    error?: string;
+}
+/**
+ * Base class for the content of a Dialog.
+ *
+ * The `body` callback passed to {@link ModuleApi.openDialog} should return an instance of a
+ * class based on this.
+ */
+export declare abstract class DialogContent<P extends DialogProps = DialogProps, S extends DialogState = DialogState, M extends object = {}> extends React.PureComponent<P, S> {
+    protected constructor(props: P, state?: S);
+    /**
+     * Run a string through the translation engine. Shortcut to ModuleApi#translateString().
+     * @param s The string.
+     * @param variables The variables, if any.
+     * @returns The translated string.
+     * @protected
+     */
+    protected t(s: string, variables?: Record<string, PlainSubstitution>): string;
+    /**
+     * Called when the dialog is submitted. Note that calling this will not submit the
+     * dialog by default - this component will be wrapped in a form which handles keyboard
+     * submission and buttons on its own.
+     *
+     * If the returned promise resolves then the dialog will be closed, otherwise the dialog
+     * will stay open.
+     */
+    abstract trySubmit(): Promise<M>;
+}

lib/components/DialogContent.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DialogContent = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+/**
+ * Base class for the content of a Dialog.
+ *
+ * The `body` callback passed to {@link ModuleApi.openDialog} should return an instance of a
+ * class based on this.
+ */
+var DialogContent = /*#__PURE__*/function (_React$PureComponent) {
+  (0, _inherits2["default"])(DialogContent, _React$PureComponent);
+
+  var _super = _createSuper(DialogContent);
+
+  function DialogContent(props, state) {
+    var _this;
+
+    (0, _classCallCheck2["default"])(this, DialogContent);
+    _this = _super.call(this, props);
+    _this.state = _objectSpread({
+      busy: false
+    }, state);
+    return _this;
+  }
+  /**
+   * Run a string through the translation engine. Shortcut to ModuleApi#translateString().
+   * @param s The string.
+   * @param variables The variables, if any.
+   * @returns The translated string.
+   * @protected
+   */
+
+
+  (0, _createClass2["default"])(DialogContent, [{
+    key: "t",
+    value: function t(s, variables) {
+      return this.props.moduleApi.translateString(s, variables);
+    }
+    /**
+     * Called when the dialog is submitted. Note that calling this will not submit the
+     * dialog by default - this component will be wrapped in a form which handles keyboard
+     * submission and buttons on its own.
+     *
+     * If the returned promise resolves then the dialog will be closed, otherwise the dialog
+     * will stay open.
+     */
+
+  }]);
+  return DialogContent;
+}(React.PureComponent);
+
+exports.DialogContent = DialogContent;

lib/components/Spinner.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+export declare class Spinner extends React.PureComponent {
+    /**
+     * The factory this component uses to render itself. Set to a different value to override.
+     * @returns The component, rendered.
+     */
+    static renderFactory: () => React.ReactNode;
+    render(): React.ReactNode;
+}