@getstep/sdk 0.0.1-security → 982.649.0

package/dist/test/ExternalAccountFactory.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bankLinkingRequest = void 0;
+const CommonProto_1 = require("../api/generated/CommonProto");
+const UserFactory_1 = require("./UserFactory");
+const bankLinkingRequest = (accountHolderName = 'JOHN SMITH') => ({
+    manual: {
+        account: {
+            accountNumber: UserFactory_1.randomNumber(12).toString(),
+            routingNumber: '322271627',
+        },
+        accountType: CommonProto_1.AchAccountType.CHECKING,
+        accountHolderName: accountHolderName,
+        bankName: 'My Bank',
+    },
+});
+exports.bankLinkingRequest = bankLinkingRequest;
+//# sourceMappingURL=ExternalAccountFactory.js.map

package/dist/test/UserFactory.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupOnboardedChild = exports.setupKycedAdult = exports.setupUsers = exports.setupUser = exports.createUser = exports.createAuthStore = exports.randomAmount = exports.randomNumber = exports.toTestToken = exports.randomAppleId = exports.randomGoogleId = exports.randomEmail = exports.randomUsername = exports.randomPhoneNumber = exports.DEFAULT_ADDRESS = exports.SSNS = exports.LAST_FOUR_SSNS = exports.WHITELISTED_VERIFY_CODE = void 0;
+const numeral_1 = __importDefault(require("numeral"));
+const uuid_1 = require("uuid");
+const AuthStore_1 = require("../store/AuthStore");
+const testing_1 = require("../store/testing");
+const legacyGenerators_1 = require("../store/testing/legacyGenerators");
+const ApiFactory_1 = require("./ApiFactory");
+exports.WHITELISTED_VERIFY_CODE = '123456';
+exports.LAST_FOUR_SSNS = {
+    test: '6789',
+    alloySuccess: '3333',
+    alloyManualReview: '2222',
+    alloyFail: '1111',
+};
+exports.SSNS = {
+    test: '123456789',
+    alloySuccess: '333333333',
+    alloyManualReview: '222222222',
+    alloyFail: '111111111',
+};
+exports.DEFAULT_ADDRESS = {
+    city: 'San Francisco',
+    country: 'US',
+    line1: '500 Folsom St Unit 4207',
+    stateProvinceRegion: 'CA',
+    zipPostalCode: '94105',
+};
+function randomPhoneNumber(forceSignup = true) {
+    // Note that the number is not a normal number, but this expands the
+    // range and help us avoid collisions for testing.
+    return `1${randomNumber(3)}${forceSignup ? 666 : 555}${randomNumber(11)}`;
+}
+exports.randomPhoneNumber = randomPhoneNumber;
+function randomUsername() {
+    return randomNumber(16).toString(16);
+}
+exports.randomUsername = randomUsername;
+/**
+ * Returns a random email.
+ *
+ * Messages will never be sent to these emails.
+ */
+function randomEmail() {
+    const random = uuid_1.v4();
+    // +nv ensures OTP is not sent and is always 123456.
+    // dev-null ensures user lifecycle emails are not sent.
+    return `dev-null+${random}+nv@step.com`;
+}
+exports.randomEmail = randomEmail;
+/**
+ * Returns a random GoogleId.
+ */
+function randomGoogleId() {
+    const random = uuid_1.v4();
+    return {
+        id: random,
+        email: randomEmail(),
+        isEmailVerified: true,
+    };
+}
+exports.randomGoogleId = randomGoogleId;
+/**
+ * Returns a random AppleId.
+ */
+function randomAppleId() {
+    const random = uuid_1.v4();
+    return {
+        id: random,
+        email: randomEmail(),
+        isEmailVerified: true,
+        isPrivateEmail: true,
+    };
+}
+exports.randomAppleId = randomAppleId;
+/**
+ * Converts SSO ID, such as GoogleId or AppleId to test token.
+ */
+function toTestToken(ssoId) {
+    const payloadStr = JSON.stringify(ssoId);
+    const payloadEncoded = Buffer.from(payloadStr).toString('base64');
+    return `test:${payloadEncoded}`;
+}
+exports.toTestToken = toTestToken;
+function randomNumber(length) {
+    const baseNumber = 10 ** (length - 1);
+    let number = Math.floor(Math.random() * baseNumber);
+    /*
+    Check if number have 0 as first digit
+    */
+    if (number < baseNumber) {
+        number += baseNumber;
+    }
+    return number;
+}
+exports.randomNumber = randomNumber;
+/**
+ * Returns a random amount.
+ *
+ * @param min minimum amount (inclusive)
+ * @param max maximum amount (inclusive)
+ * @param currency currency
+ */
+function randomAmount(min, max, currency = 'USD') {
+    const range = max - min;
+    const amount = min + Math.floor(Math.random() * range);
+    return { currency, value: numeral_1.default(amount).format('0.00') };
+}
+exports.randomAmount = randomAmount;
+function createAuthStore(baseUrl, props = {}) {
+    const { settings = ApiFactory_1.tokenSettings(), storage = ApiFactory_1.tokenStorage() } = props;
+    const client = ApiFactory_1.httpClient(baseUrl);
+    return new AuthStore_1.AuthStore(client, settings, storage);
+}
+exports.createAuthStore = createAuthStore;
+async function createUser(baseUrl, keys, options = {}) {
+    const { settings = ApiFactory_1.tokenSettings(), storage = ApiFactory_1.tokenStorage(), device = ApiFactory_1.deviceToken, keyPassword: newPassword, keyAuthenticator = {
+        authenticate: (onPassword) => onPassword(newPassword),
+    }, } = options;
+    const authStore = createAuthStore(baseUrl, { settings, storage });
+    const session = await authStore.startOnboarding(randomPhoneNumber(true));
+    const auth = await authStore.continueOnboarding(session.id, { password: exports.WHITELISTED_VERIFY_CODE }, await device());
+    const api = await ApiFactory_1.createApi(baseUrl, auth.auth, {
+        device,
+        keyAuthenticator,
+    });
+    await api.resetKeys(keys, {
+        newPassword,
+    });
+    return Object.assign(Object.assign({}, auth), { auth: api.tokenProvider });
+}
+exports.createUser = createUser;
+async function setupUser(baseUrl, request) {
+    return (await setupUsers(baseUrl, [request]))[0];
+}
+exports.setupUser = setupUser;
+async function setupUsers(baseUrl, requests, linker = () => undefined) {
+    const builder = new testing_1.CreateUserBuilder(ApiFactory_1.createTestApi(baseUrl), () => ApiFactory_1.httpClient(baseUrl));
+    return await builder.addUsers(requests).link(linker).execute();
+}
+exports.setupUsers = setupUsers;
+async function setupKycedAdult(baseUrl) {
+    return await setupUser(baseUrl, legacyGenerators_1.kycedAdult());
+}
+exports.setupKycedAdult = setupKycedAdult;
+async function setupOnboardedChild(baseUrl) {
+    return await setupUser(baseUrl, legacyGenerators_1.onboardedChild());
+}
+exports.setupOnboardedChild = setupOnboardedChild;
+//# sourceMappingURL=UserFactory.js.map

package/dist/test/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AccountFactory"), exports);
+__exportStar(require("./ApiFactory"), exports);
+__exportStar(require("./DebitCardFactory"), exports);
+__exportStar(require("./ExternalAccountFactory"), exports);
+__exportStar(require("./UserFactory"), exports);
+//# sourceMappingURL=index.js.map

package/dist/util/Assert.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notEmpty = exports.mustExist = exports.AssertionFailure = void 0;
+const Format_1 = require("./Format");
+/**
+ * A custom error that represents an assertion failed. Takes a list of objects to output, which
+ * are formatted the same way as `console.error()`.
+ */
+class AssertionFailure extends Error {
+    constructor(...args) {
+        super(Format_1.format(args));
+    }
+}
+exports.AssertionFailure = AssertionFailure;
+/**
+ * A helper to assert that an nullable value has a value.
+ */
+function mustExist(value, message) {
+    if (notEmpty(value))
+        return value;
+    throw new AssertionFailure(message || 'Value is expected but got none.');
+}
+exports.mustExist = mustExist;
+/**
+ * A helper to assert that a value is not null or undefined, for example:
+ *   const array: (string | null)[] = ['foo', null, 'bar']
+ *   const filtered: string[] = array.filter(notEmpty)
+ */
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+exports.notEmpty = notEmpty;
+//# sourceMappingURL=Assert.js.map

package/dist/util/Chaos.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Chaos = void 0;
+/**
+ * Random chaos generator. Could be used to find race conditions.
+ */
+const Random_1 = require("./Random");
+const Sleep_1 = require("./Sleep");
+class Chaos {
+    static async generate(name, operation) {
+        await Chaos.delay(name);
+        await Chaos.error(name);
+        return operation();
+    }
+    static async delay(name) {
+        if (!Chaos.useDelay)
+            return;
+        const delayMs = Random_1.randomNumber({ min: 0, max: Chaos.maxDelayMs });
+        if (delayMs) {
+            console.debug(`[${name}] Adding load chaos delay: ${delayMs} ms.`);
+        }
+        return await Sleep_1.sleep(delayMs);
+    }
+    static async error(name) {
+        if (!Chaos.useError)
+            return;
+        if (Random_1.randomNumber({ min: 1, max: 100 }) <= this.errorRatePercent) {
+            console.warn(`[${name}] Chaos random error is thrown.`);
+            throw new Error('Chaos random error');
+        }
+    }
+}
+exports.Chaos = Chaos;
+Chaos.useDelay = false;
+Chaos.useError = false;
+Chaos.maxDelayMs = 300;
+Chaos.errorRatePercent = 1;
+//# sourceMappingURL=Chaos.js.map

package/dist/util/ConsoleStamp.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleStamp = void 0;
+const dateformat_1 = __importDefault(require("dateformat"));
+/**
+ * This is a very simple port of `console-stamp` (https://github.com/starak/node-console-stamp).
+ *
+ * Basically, console-stamp would do exactly what we need, but it is incompatible with Jest because
+ * it writes directly to STDOUT, which Jest intercepts. If we modify the arguments to console, it
+ * works perfectly though.
+ */
+const consoleStamp = function (con, pattern) {
+    // If the console is patched already, restore it
+    if (con.__ts__ && 'restoreConsole' in con) {
+        con.restoreConsole();
+    }
+    // Set of log functions to override
+    const allowedLogFunctions = [
+        'debug',
+        'log',
+        'info',
+        'warn',
+        'error',
+        'assert',
+        'dir',
+    ];
+    // Keep a copy of the original console functions, so we can restore them later
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    const originalFunctions = [];
+    for (const f of allowedLogFunctions) {
+        originalFunctions.push([f, con[f]]);
+        // Grab the original function
+        const orig = con[f];
+        // Apply the override
+        con[f] = function () {
+            const prefix = `${dateformat_1.default(pattern)}`;
+            const args = [prefix, ...arguments];
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return orig.apply(con, args);
+        };
+    }
+    con.restoreConsole = () => {
+        originalFunctions.forEach((pair) => {
+            con[pair[0]] = pair[1];
+            delete con.__ts__;
+        });
+        delete con.restoreConsole;
+    };
+    con.__ts__ = true;
+};
+exports.consoleStamp = consoleStamp;
+//# sourceMappingURL=ConsoleStamp.js.map

package/dist/util/Date.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.durationAsMilliseconds = void 0;
+const date_fns_1 = require("date-fns");
+/**
+ * Converts a date-fns Duration object to milliseconds.
+ */
+function durationAsMilliseconds(duration) {
+    return +date_fns_1.add(0, duration);
+}
+exports.durationAsMilliseconds = durationAsMilliseconds;
+//# sourceMappingURL=Date.js.map

package/dist/util/Format.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+const util_1 = __importDefault(require("util"));
+/**
+ * Helper function to do console-style formatting of a list of objects. Example:
+ *
+ *     format('Person Details:', 123, {name: 'John'})
+ *     // => "Person Details: 123 { name: 'John' }"
+ */
+function format(...args) {
+    const strings = args.map((x) => {
+        return x === null || typeof x !== 'object' ? `${x}` : util_1.default.inspect(x);
+    });
+    return strings.join(' ');
+}
+exports.format = format;
+//# sourceMappingURL=Format.js.map

package/dist/util/Names.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFirstSymbol = exports.fullNameForCard = exports.initials = exports.normalizeName = exports.asPossessive = exports.abbreviatedFullName = exports.fullName = exports.splitNames = exports.maxNamePartLength = exports.maxCardholderNameLength = void 0;
+const grapheme_splitter_1 = __importDefault(require("grapheme-splitter"));
+const splitter = new grapheme_splitter_1.default();
+/**
+ * Maximum cardholder name length that is supported by Stripe.
+ */
+exports.maxCardholderNameLength = 21;
+/**
+ * The maximum length of either the first or last name.
+ */
+exports.maxNamePartLength = exports.maxCardholderNameLength - 2;
+// TODO (matthew):  that this is an unreliable way to get first and last
+// name, we should fix on server side (have server pass us separate
+// first / last name fields)
+function splitNames(fullName) {
+    const words = fullName.trim().split(' ');
+    if (words.length === 0) {
+        return { firstName: '', lastName: '' };
+    }
+    else if (words.length === 1) {
+        return { firstName: words[0], lastName: '' };
+    }
+    return { firstName: words[0], lastName: words.slice(1).join(' ') };
+}
+exports.splitNames = splitNames;
+/**
+ * Join a first and last name together, removing extraneous whitespace
+ */
+function fullName(firstName, lastName) {
+    return [firstName, lastName]
+        .map((x) => x.trim())
+        .filter((x) => x)
+        .join(' ');
+}
+exports.fullName = fullName;
+/**
+ * Create a full name that is abbreviated, by taking only the last initial of last name.
+ * Example: abbreviatedFullName('John', 'Doe') => 'John D'
+ */
+function abbreviatedFullName(firstName, lastName) {
+    if (!lastName) {
+        return firstName;
+    }
+    else if (!firstName) {
+        return lastName;
+    }
+    const lastInitial = getFirstSymbol(lastName).toUpperCase();
+    return `${firstName} ${lastInitial}`;
+}
+exports.abbreviatedFullName = abbreviatedFullName;
+/**
+ * Ensure the right possessive form in English ex. Chris will become Chris' and John will become John's
+ *
+ * @param fullName the name to add the possessive suffix to
+ * @return the name including the correct possessive suffix
+ */
+function asPossessive(fullName) {
+    // Add possessive suffix
+    return fullName.endsWith('s') || fullName.endsWith('S')
+        ? `${fullName}’`
+        : `${fullName}’s`;
+}
+exports.asPossessive = asPossessive;
+/**
+ * Normalize first or last name
+ * @param name
+ */
+function normalizeName(name) {
+    return name.trim();
+}
+exports.normalizeName = normalizeName;
+/**
+ * Returns initials (first letters) of the passed first and last names.
+ */
+function initials(firstName, lastName) {
+    return [firstName, lastName]
+        .map((x) => x.trim())
+        .filter(Boolean)
+        .map((x) => getFirstSymbol(x).toUpperCase())
+        .join('');
+}
+exports.initials = initials;
+/**
+ * Returns a cardholder name that fits on card. If name is too long, we start by truncating the
+ * first name to just an initial.
+ */
+function fullNameForCard(firstName, lastName) {
+    // Attempt to use full name, if it fits.
+    let name = fullName(firstName, lastName);
+    // If too long, try truncating first name to just an initial.
+    if (name.length > exports.maxCardholderNameLength && firstName.length > 0) {
+        name = fullName(`${getFirstSymbol(firstName)}.`, lastName);
+    }
+    // Ok, just truncate it so it will fit.
+    if (name.length > exports.maxCardholderNameLength) {
+        name = name.slice(0, exports.maxCardholderNameLength);
+    }
+    return name;
+}
+exports.fullNameForCard = fullNameForCard;
+function getFirstSymbol(str = '') {
+    return splitter.splitGraphemes(str)[0];
+}
+exports.getFirstSymbol = getFirstSymbol;
+//# sourceMappingURL=Names.js.map

package/dist/util/Phones.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reservedPhoneRange = exports.parsePhoneNumber = exports.formatPhoneNumber = exports.normalizePhoneNumber = exports.formatPartialPhoneNumber = exports.onPhoneNumberChanged = exports.verificationCodeValidationSchema = exports.phoneNumberValidationSchema = exports.affinePhoneNumberFormats = exports.phoneNumberInputMask = void 0;
+const libphonenumber_js_1 = require("libphonenumber-js");
+const yup_1 = require("yup");
+// Keep a cached formatter, so we don't create a ton of objects unnecessarily
+const formatter = new libphonenumber_js_1.AsYouType('US');
+// Regex for common US phone number formats
+const nationalPatterns = /^(\+?1[\s\.-]?)?\(?(\d{3})\)?[\s\.-]?(\d{3})[\s\.-]?(\d{4})$/;
+// Regex for extended phone numbers
+const extendedPatterns = /^1\d{17}/;
+const EMPTY_PHONE_NUMBER = Object.freeze({
+    formatted: '',
+    international: '',
+    digits: '',
+    valid: false,
+});
+// TODO (jasond): Almost all the functions in this module are specific to US phone numbers.
+exports.phoneNumberInputMask = '([000]) [000]-[0000]';
+exports.affinePhoneNumberFormats = [
+    '+1 ([000]) [000]-[0000]',
+    '1 ([000]) [000]-[0000]',
+];
+const phoneNumberValidationSchema = (errorMessage) => yup_1.string()
+    .test('phoneNumber', errorMessage, (value = '') => {
+    try {
+        const phone = libphonenumber_js_1.parsePhoneNumber(value, 'US');
+        return phone.isValid() && !phone.ext;
+    }
+    catch (error) {
+        return false;
+    }
+})
+    .required();
+exports.phoneNumberValidationSchema = phoneNumberValidationSchema;
+const verificationCodeValidationSchema = (errorMessage) => yup_1.string()
+    .required(errorMessage)
+    .min(6)
+    .max(6)
+    .test('code', 'code needs to be numeric', (value = '') => {
+    return value.match(/[0-9]+/g) !== null;
+});
+exports.verificationCodeValidationSchema = verificationCodeValidationSchema;
+function onPhoneNumberChanged(value) {
+    const unFormattedPhoneNumber = value.replace(/[()-/\s]/g, '');
+    if (unFormattedPhoneNumber.length <= 4) {
+        return unFormattedPhoneNumber;
+    }
+    formatter.reset();
+    return formatter.input(unFormattedPhoneNumber);
+}
+exports.onPhoneNumberChanged = onPhoneNumberChanged;
+/**
+ * Returns our best attempt to nicely format a phone number, even if it is not completely defined.
+ */
+function formatPartialPhoneNumber(value) {
+    if (value.match(/[a-z]/i)) {
+        // If any alphabetic characters are found, don't treat as phone number
+        return '';
+    }
+    // Strip leading plus sign, it will interfere with formatting
+    formatter.reset();
+    const formatted = formatter.input(value.trim().replace(/^\+/, ''));
+    // Strip leading international code if it is US
+    return formatted.replace(/^1 \(/, '(');
+}
+exports.formatPartialPhoneNumber = formatPartialPhoneNumber;
+function normalizePhoneNumber(phoneNumber, mustBeValid = true) {
+    const parsed = parsePhoneNumber(phoneNumber, mustBeValid);
+    if (!mustBeValid || parsed.valid)
+        return parsed.digits;
+    return '';
+}
+exports.normalizePhoneNumber = normalizePhoneNumber;
+function formatPhoneNumber(phoneNumber, mustBeValid) {
+    const parsed = parsePhoneNumber(phoneNumber, mustBeValid);
+    return parsed.valid ? parsed.formatted : phoneNumber;
+}
+exports.formatPhoneNumber = formatPhoneNumber;
+/**
+ * Parse a string as a phone number, returning a structured object with both normalized and
+ * formatted versions of the phone number.
+ */
+function parsePhoneNumber(value, mustBeValid = true) {
+    // Don't do a bunch of expensive up-front processing if the string is empty
+    if (value.length === 0) {
+        return EMPTY_PHONE_NUMBER;
+    }
+    // Performance optimization: Use a regex-based parser for common US formats
+    const match = value.match(nationalPatterns);
+    if (match) {
+        return {
+            formatted: `(${match[2]}) ${match[3]}-${match[4]}`,
+            international: `+1 ${match[2]} ${match[3]} ${match[4]}`,
+            digits: `1${match[2]}${match[3]}${match[4]}`,
+            valid: true,
+        };
+    }
+    // Allow extended phone numbers for dev builds
+    // TODO (jasond): Server only supports signup with extended phone number, not inviting. See:
+    // https://trello.com/c/2QKKpzuo
+    if (mustBeValid && value.match(extendedPatterns)) {
+        return {
+            formatted: value,
+            international: value,
+            digits: value,
+            valid: true,
+        };
+    }
+    // Parse the phone number
+    const parsedNumber = libphonenumber_js_1.parsePhoneNumberFromString(value, 'US');
+    if (!parsedNumber) {
+        return EMPTY_PHONE_NUMBER;
+    }
+    // Apply our requirements for valid phone numbers
+    const valid = parsedNumber.isValid() &&
+        parsedNumber.country === 'US' &&
+        parsedNumber.number.length === 11 &&
+        !parsedNumber.ext;
+    return {
+        formatted: parsedNumber.formatNational(),
+        international: parsedNumber.formatInternational(),
+        digits: parsedNumber.number.slice(1),
+        valid,
+    };
+}
+exports.parsePhoneNumber = parsePhoneNumber;
+/**
+ * Returns true if the given phone number falls in a reserved range, and should not be used.
+ */
+function reservedPhoneRange(value) {
+    const patterns = [/^1907555/, /^1650555070[56789]/];
+    return !!patterns.find((re) => re.test(value));
+}
+exports.reservedPhoneRange = reservedPhoneRange;
+//# sourceMappingURL=Phones.js.map

package/dist/util/PublicProfile.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublicProfile = void 0;
+const ProfileProto = __importStar(require("../api/generated/ProfileProto"));
+const Url_1 = require("./Url");
+/**
+ * This is a readonly class for various user public profiles.
+ */
+class PublicProfile {
+    constructor(source) {
+        Object.assign(this, source);
+        Object.seal(this);
+    }
+    /**
+     * Returns true if the profile is accessible to general public.
+     * Everywhere. For everyone. Technically forever, because nothing is ever gone from the internet.
+     */
+    get isPublic() {
+        return this.status === ProfileProto.Status.PUBLIC && !!this.username;
+    }
+    /**
+     * Generates pathnname for the profile, and appends it to `basePublicUrl`
+     * @param basePublicUrl - The base url to use. E.g. https://step.com/. Slashes don't matter.
+     */
+    generateUrl(basePublicUrl) {
+        if (!this.username)
+            return;
+        const url = Url_1.parseUrl(basePublicUrl);
+        url.set('pathname', `$/${this.username}`);
+        return {
+            href: url.toString(),
+            preview: url.hostname.concat(url.pathname),
+        };
+    }
+}
+exports.PublicProfile = PublicProfile;
+//# sourceMappingURL=PublicProfile.js.map