expensify-common 1.0.1 → 2.0.2

package/{lib/components/CopyText.jsx → dist/components/CopyText.js}

@@ -1,23 +1,23 @@
-import React from 'react';
-import Clipboard from 'clipboard'
-import PropTypes from 'prop-types';
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const clipboard_1 = __importDefault(require("clipboard"));
+const prop_types_1 = __importDefault(require("prop-types"));
 const propTypes = {
     // Callback fired when text has been copied - useful to display UI confirmation
-    onSuccess: PropTypes.func,
-
+    onSuccess: prop_types_1.default.func,
     // The text to be copied
-    textContent: PropTypes.string,
-
+    textContent: prop_types_1.default.string,
     // Function as a child exposes the copyTextToClipboard fuction
-    children: PropTypes.func.isRequired
+    children: prop_types_1.default.func.isRequired,
 };
-
 const defaultProps = {
-    onSuccess: () => {},
+    onSuccess: () => { },
     textContent: '',
 };
-
 /**
  * Simple render prop component that encapsulates the Clipboard feature and exposes a function that can be tied to any event
  *
@@ -31,38 +31,31 @@ const defaultProps = {
  *     )}
  * </React.c.CopyText>
  */
-class CopyText extends React.Component {
+class CopyText extends react_1.default.Component {
     componentDidMount() {
         this.hiddenLink = document.createElement('a');
-
         // Sets up the clipboard instance
-        this.clipboard = new Clipboard(this.hiddenLink, {
-            text: () => this.props.textContent
+        this.clipboard = new clipboard_1.default(this.hiddenLink, {
+            text: () => this.props.textContent,
         });
-
         // Fires callback when the clipboard has succesfully copied
         this.clipboard.on('success', () => {
             this.props.onSuccess();
         });
     }
-
     componentWillUnmount() {
         this.clipboard.destroy();
     }
-
     /**
      * Fires click event on invisible link
      */
     copyTextToClipboard() {
         this.hiddenLink.click();
     }
-
     render() {
         return this.props.children(() => this.copyTextToClipboard());
     }
 }
-
 CopyText.propTypes = propTypes;
 CopyText.defaultProps = defaultProps;
-
-export default CopyText;
+exports.default = CopyText;

package/dist/components/StepProgressBar.d.ts

@@ -0,0 +1,22 @@
+export default StepProgressBar;
+/**
+ * Step progress bar.
+ *
+ * @param {array} steps of {id, title}
+ * @param {string} currentStep id
+ *
+ * @return {React.Component}
+ */
+declare function StepProgressBar({ steps, currentStep }: array): React.Component;
+declare namespace StepProgressBar {
+    export { propTypes };
+}
+import React from 'react';
+declare namespace propTypes {
+    let steps: PropTypes.Validator<(PropTypes.InferProps<{
+        id: PropTypes.Validator<string>;
+        title: PropTypes.Validator<string>;
+    }> | null | undefined)[]>;
+    let currentStep: PropTypes.Validator<string>;
+}
+import PropTypes from 'prop-types';

package/dist/components/StepProgressBar.js

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = __importDefault(require("react"));
+const underscore_1 = __importDefault(require("underscore"));
+const prop_types_1 = __importDefault(require("prop-types"));
+const classnames_1 = __importDefault(require("classnames"));
+const UIConstants = __importStar(require("../CONST"));
+const stepShape = {
+    id: prop_types_1.default.string.isRequired,
+    title: prop_types_1.default.string.isRequired,
+};
+const propTypes = {
+    steps: prop_types_1.default.arrayOf(prop_types_1.default.shape(stepShape)).isRequired,
+    currentStep: prop_types_1.default.string.isRequired,
+};
+/**
+ * Step progress bar.
+ *
+ * @param {array} steps of {id, title}
+ * @param {string} currentStep id
+ *
+ * @return {React.Component}
+ */
+function StepProgressBar({ steps, currentStep }) {
+    const isCurrentStep = (step) => step.id === currentStep;
+    const currentStepIndex = Math.max(0, underscore_1.default.findIndex(steps, isCurrentStep));
+    const renderStep = (step, i) => {
+        let status = currentStepIndex === i ? UIConstants.UI.ACTIVE : '';
+        if (currentStepIndex > i) {
+            status = 'complete';
+        }
+        return (react_1.default.createElement("div", { key: step.id, className: (0, classnames_1.default)('progress-step', 'js_step', step.id, status) },
+            react_1.default.createElement("div", { className: "progress-dot" },
+                react_1.default.createElement("div", { className: "inner" })),
+            react_1.default.createElement("div", { className: "progress-desc" },
+                react_1.default.createElement("span", { className: "js_step_title" }, step.title))));
+    };
+    return (react_1.default.createElement("div", { id: "js_steps_progress", className: "progress-wrapper" },
+        react_1.default.createElement("div", { className: "progress" }, underscore_1.default.map(steps, renderStep))));
+}
+StepProgressBar.propTypes = propTypes;
+exports.default = StepProgressBar;

package/dist/components/form/element/combobox.d.ts

@@ -0,0 +1,237 @@
+export default Combobox;
+/**
+ * A combobox useful for searching for values in a large list
+ */
+declare class Combobox extends React.Component<any, any, any> {
+    constructor(props: any);
+    /**
+     * @param {Boolean} noDefaultValue Overrides the default value to have '' as the currentValue
+     * @param {Object[]} [newOptions] when resetting this component, we can specify new options to use
+     * @param {Object[]} [newAlreadySelectedOptions] when resetting this component, we can specify new already selected options to use
+     *
+     * @returns {Object}
+     */
+    getStartState(noDefaultValue: boolean, newOptions?: Object[] | undefined, newAlreadySelectedOptions?: Object[] | undefined): Object;
+    /**
+     * Returns a set of our full options according to the maxItemsToShow
+     *
+     * @param {String|Number} currentValue
+     * @param {Object[]} [newAlreadySelectedOptions]
+     * @returns {Array}
+     */
+    getTruncatedOptions(currentValue: string | number, newAlreadySelectedOptions?: Object[] | undefined): any[];
+    /**
+     * Returns the selected value(s)
+     *
+     * @return {String}
+     */
+    getValue(): string;
+    /**
+     * Sets the current value
+     *
+     * @param {String} val
+     */
+    setValue(val: string): void;
+    /**
+     * Hard sets the current text to what we want
+     *
+     * @param {String} val
+     */
+    setText(val: string): void;
+    /**
+     * Sets the disabled state of this component
+     *
+     * @param {Boolean} isDisabled
+     */
+    setDisabled(isDisabled: boolean): void;
+    /**
+     * Set an error for a specific tag
+     */
+    setError(): void;
+    /**
+     * Deselects any current option if it exists
+     */
+    deselectCurrentOption(): void;
+    /**
+     * Swaps the focused index from {oldFocusedIndex} to {newFocusedIndex}
+     *
+     * @param {number} oldFocusedIndex
+     * @param {number} newFocusedIndex
+     */
+    switchFocusedIndex(oldFocusedIndex: number, newFocusedIndex: number): void;
+    /**
+     * Returns the selector to it's original state
+     *
+     * @param {Boolean} noDefaultValue Overrides the initials state defaultValue by setting the currentValue to ''
+     * @param {Object[]} [newOptions] we can recreate it with new options
+     * @param {Object[]} [newAlreadySelectedOptions] we can recreate it with new already selected options
+     */
+    reset(noDefaultValue: boolean, newOptions?: Object[] | undefined, newAlreadySelectedOptions?: Object[] | undefined): void;
+    /**
+     * When the dropdown is closed, we reset the focused property of all of our options
+     */
+    resetFocusedElements(): void;
+    /**
+     * Fired when we "click away" with the dropdown open
+     *
+     * @param {SyntheticEvent} e
+     */
+    handleClickAway(e: SyntheticEvent): void;
+    /**
+     * Sets a clicklistener to close the dropdown if it is currently open
+     */
+    resetClickAwayHandler(): void;
+    /**
+     * Clear an error for a specific tag
+     */
+    clearError(): void;
+    /**
+     * Opens or closes the dropdown
+     */
+    toggleDropdown(): void;
+    /**
+     * Just open the dropdown (when the input gets focus)
+     */
+    openDropdown(): void;
+    /**
+     * Closes the dropdown and removes the click handler that calls this function after the dropdown is closed
+     *
+     * @param {SyntheticEvent} [e]
+     */
+    closeDropdown(e?: any): void;
+    /**
+     * If the user presses tab when the dropdown button is focused, then we close the dropdown
+     * because they are trying to get to the next form components
+     *
+     * @param {SyntheticEvent} e
+     */
+    closeDropdownOnTabOut(e: SyntheticEvent): void;
+    /**
+     * Stops events from doing anything outside of the current function (in theory).
+     * This doesn't work between jquery and React events because React's event propagation is a separate system.
+     *
+     * @param {SyntheticEvent} e
+     */
+    stopEvent(e: SyntheticEvent): void;
+    /**
+     * This is triggered whenever there is a key up event in the text input
+     *
+     * @param {SyntheticEvent} e
+     */
+    handleKeyDown(e: SyntheticEvent): void;
+    /**
+     * This is triggered whenever there is a change event in the text input
+     * (from any valid input that's not being handled from the keyUp event)
+     *
+     * @param {SyntheticEvent} e
+     */
+    performSearch(e: SyntheticEvent): void;
+    /**
+     * Handle state changes for when a user clicks on an item in the dropdown
+     *
+     * @param  {String|Number} selectedValue
+     */
+    handleClick(selectedValue: string | number): void;
+    state: Object;
+    scrollPosition: number;
+    componentDidMount(): void;
+    UNSAFE_componentWillReceiveProps(nextProps: any): void;
+    componentDidUpdate(): void;
+    componentWillUnmount(): void;
+    initialValue: any;
+    options: any;
+    initialText: any;
+    render(): React.JSX.Element | null;
+    value: HTMLInputElement | null | undefined;
+    dropDown: DropDown | null | undefined;
+}
+declare namespace Combobox {
+    export { propTypes };
+    export { defaultProps };
+}
+import React from 'react';
+import DropDown from './dropdown';
+declare namespace propTypes {
+    let options: PropTypes.Validator<(PropTypes.InferProps<{
+        value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        text: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        hasError: PropTypes.Requireable<boolean>;
+        disabled: PropTypes.Requireable<boolean>;
+        id: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        divider: PropTypes.Requireable<boolean>;
+        selected: PropTypes.Requireable<boolean>;
+    }> | null | undefined)[]>;
+    let defaultValue: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+    let value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+    let alreadySelectedOptions: PropTypes.Requireable<(PropTypes.InferProps<{
+        value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        text: PropTypes.Requireable<string>;
+    }> | null | undefined)[]>;
+    let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    let onClear: PropTypes.Requireable<(...args: any[]) => any>;
+    let onDropdownStateChange: PropTypes.Requireable<(...args: any[]) => any>;
+    let maxItemsToShow: PropTypes.Requireable<number>;
+    let maxSearchResults: PropTypes.Requireable<number>;
+    let propertyToDisplay: PropTypes.Requireable<string>;
+    let openOnInit: PropTypes.Requireable<boolean>;
+    let allowAnyValue: PropTypes.Requireable<boolean>;
+    let noResultsText: PropTypes.Requireable<string>;
+    let isReadOnly: PropTypes.Requireable<boolean>;
+    let placeholder: PropTypes.Requireable<string>;
+    let extraClasses: PropTypes.Requireable<NonNullable<string | object | null | undefined>>;
+    let hideUntilManuallyOpened: PropTypes.Requireable<boolean>;
+    let alwaysShowSelectedOnTop: PropTypes.Requireable<boolean>;
+    let hasInitialError: PropTypes.Requireable<boolean>;
+    let bs4: PropTypes.Requireable<boolean>;
+    let showDisabledOptionsInResults: PropTypes.Requireable<boolean>;
+    let autoScrollToTop: PropTypes.Requireable<boolean>;
+    let dropDownClasses: PropTypes.Requireable<NonNullable<string | object | null | undefined>>;
+}
+declare namespace defaultProps {
+    let defaultValue_1: string;
+    export { defaultValue_1 as defaultValue };
+    let value_1: string;
+    export { value_1 as value };
+    export function onChange_1(): void;
+    export { onChange_1 as onChange };
+    export function onClear_1(): void;
+    export { onClear_1 as onClear };
+    export function onDropdownStateChange_1(): void;
+    export { onDropdownStateChange_1 as onDropdownStateChange };
+    let maxItemsToShow_1: number;
+    export { maxItemsToShow_1 as maxItemsToShow };
+    let maxSearchResults_1: number;
+    export { maxSearchResults_1 as maxSearchResults };
+    let propertyToDisplay_1: string;
+    export { propertyToDisplay_1 as propertyToDisplay };
+    let allowAnyValue_1: boolean;
+    export { allowAnyValue_1 as allowAnyValue };
+    let openOnInit_1: boolean;
+    export { openOnInit_1 as openOnInit };
+    let isReadOnly_1: boolean;
+    export { isReadOnly_1 as isReadOnly };
+    let alreadySelectedOptions_1: never[];
+    export { alreadySelectedOptions_1 as alreadySelectedOptions };
+    let noResultsText_1: string;
+    export { noResultsText_1 as noResultsText };
+    let placeholder_1: string;
+    export { placeholder_1 as placeholder };
+    let extraClasses_1: never[];
+    export { extraClasses_1 as extraClasses };
+    let hideUntilManuallyOpened_1: boolean;
+    export { hideUntilManuallyOpened_1 as hideUntilManuallyOpened };
+    let alwaysShowSelectedOnTop_1: boolean;
+    export { alwaysShowSelectedOnTop_1 as alwaysShowSelectedOnTop };
+    let hasInitialError_1: boolean;
+    export { hasInitialError_1 as hasInitialError };
+    let bs4_1: boolean;
+    export { bs4_1 as bs4 };
+    let showDisabledOptionsInResults_1: boolean;
+    export { showDisabledOptionsInResults_1 as showDisabledOptionsInResults };
+    let autoScrollToTop_1: boolean;
+    export { autoScrollToTop_1 as autoScrollToTop };
+    let dropDownClasses_1: never[];
+    export { dropDownClasses_1 as dropDownClasses };
+}
+import PropTypes from 'prop-types';