@todesktop/shared 7.191.0 → 7.191.1

package/lib/cjs/validations.js

@@ -0,0 +1,178 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 });
+exports.shouldMinimizeToTrayIsActive = exports.appConfigValidation = exports.appProtocolValidation = exports.internalAppRegexValidation = exports.widthValidation = exports.heightValidation = exports.urlValidationForm = exports.urlValidation = exports.iconValidation = exports.forceVersionValidation = exports.appTitleValidation = void 0;
+const is_regex_1 = __importDefault(require("is-regex"));
+const semver_1 = __importDefault(require("semver"));
+const yup = __importStar(require("yup"));
+exports.appTitleValidation = yup
+    .string()
+    .label('App title')
+    .max(26)
+    .matches(/^[\w\-\s]+$/, 'App title may contain letters, numbers, spaces and dashes only')
+    .matches(/^[^\s]+(\s+[^\s]+)*$/, 'App title may not begin or end with space')
+    .required();
+function isNumeric(str) {
+    if (typeof str !== 'string')
+        return false;
+    return !Number.isNaN(Number(str)) && !Number.isNaN(parseFloat(str));
+}
+function isNumericSemver(value) {
+    // check if valid semver
+    if (!semver_1.default.valid(value))
+        return false;
+    // ensure that all values are numbers
+    if (!value.split('.').every((num) => isNumeric(num)))
+        return false;
+    return true;
+}
+exports.forceVersionValidation = yup
+    .string()
+    .label('App version')
+    .required()
+    // can have multiple keys included - https://www.npmjs.com/package/yup#schemawhenkeys-string--string-builder-object--values-any-schema--schema-schema
+    .when('$currentVersion', ([currentVersion], schema) => schema.test('semantic-version', 'App version must follow a numeric SemVer versioning scheme (e.g. 1.0.0) and be greater than prior version.', (forceVersion) => {
+    return (isNumericSemver(forceVersion) &&
+        semver_1.default.gt(forceVersion, currentVersion));
+}));
+exports.iconValidation = yup
+    .string()
+    .label('Icon')
+    .url()
+    .required('You must upload an icon for your app');
+exports.urlValidation = yup
+    .string()
+    .matches(/^(?:([a-z0-9+.-]+):\/\/)(?:\S+(?::\S*)?@)?(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*\.?)(?::\d{2,5})?(?:[/?#]\S*)?$/, {
+    excludeEmptyString: true,
+    message: "Invalid URL. Don't forget to include the protocol (e.g.. https://).",
+})
+    .label('Website URL')
+    .required();
+exports.urlValidationForm = yup.object().shape({
+    url: exports.urlValidation,
+});
+exports.heightValidation = yup
+    .number()
+    .label('Height')
+    .moreThan(1)
+    .lessThan(2000)
+    .required();
+exports.widthValidation = yup
+    .number()
+    .label('Width')
+    .moreThan(1)
+    .lessThan(3000)
+    .required();
+exports.internalAppRegexValidation = yup
+    .string()
+    .required()
+    .label('Internal URLs')
+    .test('escape-forward-slash', "a forward-slash ('/') must be escaped with a back-slash ('\\')", (value) => {
+    if (value.includes('/')) {
+        const forwardSlashCount = value
+            .split('')
+            .map((char) => char === '/')
+            .filter((isTrue) => isTrue).length;
+        const backSlashEscapeCount = ((value || '').match(/(?=\\\/)/g) || [])
+            .length;
+        return forwardSlashCount === backSlashEscapeCount;
+    }
+    return true;
+})
+    .test('is-regex', 
+// eslint-disable-next-line no-template-curly-in-string
+'${path} must be valid regular expression', (value) => (0, is_regex_1.default)(RegExp(value)));
+exports.appProtocolValidation = yup
+    .string()
+    .required()
+    .label('App Protocol')
+    .test('ends-with-protocol', 'Protocols must end with `://`', (value) => value.endsWith('://'))
+    .test('is-lowercase', 'Protocols must be lowercase', (value) => value === value.toLowerCase())
+    .matches(/^[a-zA-Z-.]+:\/\/$/, 'Protocols contain letters, dots (.) and dashes (-) only')
+    .min(5);
+exports.appConfigValidation = yup.object({
+    customUserAgent: yup.string().required(),
+    disableDevTools: yup.boolean().required(),
+    iconUrl: exports.iconValidation,
+    id: yup.string().required(),
+    internalURLs: yup.string().required(),
+    isFrameBlocked: yup.boolean().required(),
+    meta: yup
+        .object({
+        appIterations: yup.number().required(),
+        hasAppChanged: yup.boolean().required(),
+        publishedVersions: yup.object({
+            desktopify: yup.string().notRequired(),
+            electron: yup.string().notRequired(),
+            version: yup.string().notRequired(),
+        }),
+        schemaVersion: yup.number().required(),
+    })
+        .required(),
+    name: exports.appTitleValidation,
+    secret: yup.string().required(),
+    singleInstance: yup.boolean().required(),
+    url: exports.urlValidation,
+    windowOptions: yup
+        .object({
+        hasMaxHeight: yup.boolean().required(),
+        hasMaxWidth: yup.boolean().required(),
+        hasMinHeight: yup.boolean().required(),
+        hasMinWidth: yup.boolean().required(),
+        height: yup.number().required(),
+        isFullscreenable: yup.boolean().required(),
+        isMaximizable: yup.boolean().required(),
+        isMinimizable: yup.boolean().required(),
+        isResizable: yup.boolean().required(),
+        maxHeight: yup.number().required(),
+        maxWidth: yup.number().required(),
+        minHeight: yup.number().required(),
+        minWidth: yup.number().required(),
+        startInFullscreenMode: yup.boolean().required(),
+        width: yup.number().required(),
+        alwaysOnTop: yup.boolean().required(),
+        autoHideMenuBar: yup.boolean().required(),
+        transparentInsetTitlebar: yup.boolean().required(),
+        transparentTitlebar: yup.boolean().required(),
+    })
+        .required(),
+});
+const shouldMinimizeToTrayIsActive = (desktopApp) => {
+    return desktopApp.trays.some((t) => t.leftClick.role === 'toggleMenu' || t.rightClick.role === 'toggleMenu');
+};
+exports.shouldMinimizeToTrayIsActive = shouldMinimizeToTrayIsActive;

package/lib/esm/base.d.ts

@@ -0,0 +1,326 @@
+import { CIRunner, ExtraFileReference, FilePath, IAppBuilderLib, PlatformName, Release } from './desktopify';
+import { MacTarget, WindowsTarget } from './hsm';
+export interface Schemable {
+    schemaVersion?: number;
+}
+type CompositeIdFileLocationKey = string;
+export type StaticAnalysisItem = {
+    hidden: boolean;
+};
+export type ProgressTypes = 'done' | 'error' | 'progress' | 'queued';
+export interface IChecklistItem {
+    [id: string]: boolean;
+}
+export interface IDownloadButtonOptions {
+    bgColor: string;
+    borderRadius: number;
+    btnText: string;
+    buttonSize: 'large' | 'medium' | 'small';
+    fgColor: string;
+    fontFamily: 'sans-serif' | 'serif';
+    showAppIcon: {
+        alignment: 'left' | 'right';
+        enabled: boolean;
+    };
+    showDownloadIcon: {
+        alignment: 'left' | 'right';
+        enabled: boolean;
+    };
+}
+export declare enum WindowsEVOnboardingSteps {
+    'hasBeenVerified' = "hasBeenVerified",
+    'hasChosenProvider' = "hasChosenProvider",
+    'hasGeneratedCert' = "hasGeneratedCert",
+    'hasOrderedCert' = "hasOrderedCert",
+    'hasUploadedCert' = "hasUploadedCert"
+}
+export declare enum WindowsEVOnboardingProvider {
+    'globalsign' = "globalsign",
+    'other' = "other"
+}
+export interface IAppBuildProgress {
+    isBuilding: boolean;
+    message: string;
+    percent: number;
+    shouldSkip: boolean;
+    type: ProgressTypes;
+}
+export interface IAppMeta {
+    appIterations?: number;
+    autoSecurityUpdatesEnabled?: boolean;
+    ciRunner?: CIRunner;
+    completedChecklistItems?: IChecklistItem;
+    currentBuildProgress?: {
+        channel?: string;
+        id?: string;
+        linux?: IAppBuildProgress;
+        mac?: IAppBuildProgress;
+        projectConfig?: ToDesktopJson;
+        releaseId?: Release['id'];
+        shouldCodeSign?: boolean;
+        shouldRelease?: boolean;
+        shouldSendCompletionEmail?: boolean;
+        sourceArchiveDetails?: {
+            bucket: string;
+            hash?: string;
+            key: string;
+            url: string;
+        };
+        windows?: IAppBuildProgress;
+    };
+    downloadButtons?: {
+        linux: IDownloadButtonOptions;
+        mac: IDownloadButtonOptions;
+        universal: IDownloadButtonOptions;
+        windows: IDownloadButtonOptions;
+    };
+    firstSuccessfulBuildEndedAt?: string;
+    forceVersionNumber?: string;
+    isAppChanged?: boolean;
+    isFrameBlocked?: boolean;
+    isHttps?: boolean;
+    latestReleaseBuildId?: string;
+    previousInstallLockSha?: string;
+    publishedVersions: {
+        desktopify?: string;
+        electron?: string;
+        version?: string;
+    };
+    releaseRedirections?: ReleaseRedirectionRule[];
+    staticAnalysis?: Record<CompositeIdFileLocationKey, StaticAnalysisItem>;
+    webhookHMACKey?: string;
+    webhooks?: {
+        release?: string;
+    };
+    windowsEVOnboarding?: {
+        [WindowsEVOnboardingSteps.hasBeenVerified]: boolean;
+        [WindowsEVOnboardingSteps.hasChosenProvider]: boolean;
+        [WindowsEVOnboardingSteps.hasGeneratedCert]: boolean;
+        [WindowsEVOnboardingSteps.hasOrderedCert]: boolean;
+        [WindowsEVOnboardingSteps.hasUploadedCert]: boolean;
+        provider: WindowsEVOnboardingProvider;
+        tempHSMCertName: string;
+    };
+}
+export interface ToDesktopJson {
+    appBuilderLibVersion?: string;
+    appFiles?: string[];
+    appId?: string;
+    appPath?: FilePath;
+    appProtocolScheme?: string | string[];
+    asar?: boolean;
+    asarUnpack?: boolean | string[];
+    bucket?: string;
+    buildVersion?: string;
+    bytenode?: {
+        enabled?: boolean;
+        files?: string[];
+    };
+    copyright?: string;
+    dmg?: {
+        artifactName?: string;
+        background?: FilePath;
+        backgroundColor?: string;
+        contents?: NonNullable<IAppBuilderLib['config']['dmg']>['contents'];
+        iconSize?: number;
+        iconTextSize?: number;
+        title?: string;
+        window?: NonNullable<IAppBuilderLib['config']['dmg']>['window'];
+    };
+    electronMirror?: string;
+    electronVersion?: string;
+    extraContentFiles?: ExtraFileReference[];
+    extraResources?: ExtraFileReference[];
+    fileAssociations?: IAppBuilderLib['config']['fileAssociations'];
+    filesForDistribution?: string[];
+    icon: FilePath;
+    id: string;
+    includeSubNodeModules?: boolean;
+    linux?: {
+        category?: string;
+        icon?: FilePath;
+        imageVersion?: string;
+        noSandbox?: boolean;
+    };
+    mac?: {
+        additionalBinariesToSign?: FilePath[];
+        category?: string;
+        dmgBackground?: FilePath;
+        entitlements?: FilePath;
+        entitlementsInherit?: FilePath;
+        extendInfo?: NonNullable<IAppBuilderLib['config']['mac']>['extendInfo'];
+        icon?: FilePath;
+        provisioningProfile?: FilePath;
+        requirements?: FilePath;
+    };
+    mas?: {
+        entitlements?: FilePath;
+        entitlementsInherit?: FilePath;
+        minimumSystemVersion?: string;
+        provisioningProfile?: FilePath;
+        type?: 'development' | 'distribution';
+        x64ArchFiles?: string;
+    };
+    nodeVersion?: string;
+    npmVersion?: string;
+    packageManager?: 'npm' | 'pnpm' | 'yarn';
+    pnpmVersion?: string;
+    productName?: string;
+    rebuildLibrary?: '@electron/rebuild' | 'app-builder';
+    schemaVersion: number;
+    snap?: IAppBuilderLib['config']['snap'];
+    updateUrlBase?: string;
+    uploadSizeLimit?: number;
+    useCachedDependencies?: boolean;
+    windows?: {
+        icon?: FilePath;
+        nsisCustomBinary?: {
+            checksum?: string;
+            debugLogging?: boolean;
+            url: string;
+            version?: string;
+        };
+        nsisInclude?: FilePath;
+        publisherName?: string[];
+    };
+    yarnVersion?: string;
+}
+export declare enum WindowsHSMCertType {
+    azureTrustedSigning = "azureTrustedSigning",
+    ev = "ev",
+    file = "file"
+}
+export interface CustomWindowsCodeSignFile {
+    certType: string;
+    hsmCertName: string;
+    hsmCertType: WindowsHSMCertType.file;
+}
+export interface CustomWindowsCodeSignEV {
+    certType: 'hsm';
+    hsmCertName: string;
+    hsmCertType: WindowsHSMCertType.ev;
+}
+export interface CustomWindowsCodeSignAzureTrustedSigning {
+    azureBaseSettings: {
+        $azureClientSecretRef: string;
+        clientId: string;
+        codeSigningAccountName: string;
+        resourceGroupName: string;
+        subscriptionId: string;
+        tenantId: string;
+    };
+    azureCredentialsStored: boolean;
+    azureSettings?: {
+        accountUri: string;
+        certificateProfileId: string;
+        certificateProfileName: string;
+        publisherName: string;
+    };
+    certType: 'azureTrustedSigning';
+}
+export type CustomMacCodeSign = {
+    certName: string;
+    certPassword: string;
+    certUrl: string;
+    type: 'url';
+} | {
+    type: 'hsm';
+};
+export type CustomLinuxPGPKey = {
+    $key: string;
+    $password?: string;
+};
+export type CustomMacNotarization = CustomNotarizationApiKeyAuth | CustomNotarizationPasswordHsmAuth;
+export interface CustomNotarizationApiKeyAuth {
+    $appleApiKey: string;
+    appleApiIssuer: string;
+    appleApiKeyId: string;
+    type: 'hsm-api';
+}
+export interface CustomNotarizationPasswordHsmAuth {
+    $appSpecificPassword: string;
+    appleId: string;
+    teamId: string;
+    type: 'hsm';
+}
+export type ReleaseRedirectionRule = {
+    appId: string;
+    ipList: string[];
+    rule: 'appByIp';
+} | {
+    appId: string;
+    rule: 'app';
+} | {
+    buildId: string;
+    ipList: string[];
+    rule: 'buildByIp';
+} | {
+    buildId: string;
+    platforms: PlatformName[];
+    rule: 'buildByPlatform';
+} | {
+    feedUrl: string;
+    ipList: string[];
+    rule: 'appByIp';
+} | {
+    feedUrl: string;
+    rule: 'app';
+};
+export interface BaseApp extends Schemable {
+    appModelId?: string;
+    appxConfig?: Partial<IAppBuilderLib['config']['appx']>;
+    customDomain?: string;
+    customLinuxPgpKey?: CustomLinuxPGPKey;
+    customMacCodeSign?: CustomMacCodeSign;
+    customNotarization?: CustomMacNotarization;
+    customWindowsCodeSign?: CustomWindowsCodeSignAzureTrustedSigning | CustomWindowsCodeSignEV | CustomWindowsCodeSignFile;
+    domainVerificationCode?: string;
+    id: string;
+    macHsmCertNames?: Record<MacTarget, string>;
+    macUniversalInstallerConfig?: {
+        shouldPinToVersion?: boolean;
+    };
+    masConfig?: {
+        arch?: 'arm64' | 'universal';
+    } & Partial<IAppBuilderLib['config']['mas']>;
+    meta?: IAppMeta;
+    nsisConfig?: Partial<IAppBuilderLib['config']['nsis']>;
+    parent?: {
+        id: string;
+        relationshipToParent: string;
+    } | null;
+    parentApp?: BaseApp;
+    shouldCreate32BitWindowsArtifacts?: boolean;
+    shouldCreateAppImages?: boolean;
+    shouldCreateAppleIntelArtifacts?: boolean;
+    shouldCreateAppleSiliconAssets?: boolean;
+    shouldCreateAppXFiles?: boolean;
+    shouldCreateArm64LinuxArtifacts?: boolean;
+    shouldCreateArm64WindowsArtifacts?: boolean;
+    shouldCreateDebianPackages?: boolean;
+    shouldCreateDMGs?: boolean;
+    shouldCreateMacAppStoreFiles?: boolean;
+    shouldCreateMacPKG?: boolean;
+    shouldCreateMacUniversalInstaller?: boolean;
+    shouldCreateMacZipInstallers?: boolean;
+    shouldCreateMSIInstallers?: boolean;
+    shouldCreateNSISInstallers?: boolean;
+    shouldCreateNSISWebInstaller?: boolean;
+    shouldCreateRPMPackages?: boolean;
+    shouldCreateSnapFiles?: boolean;
+    snapStore?: {
+        description?: string;
+        login?: string;
+    };
+    subscription?: Subscription;
+    windowsHsmCertNames?: Record<WindowsTarget, string>;
+}
+export type Subscription = {
+    itemId: string;
+    planId: string;
+    priceId?: string;
+    productId?: string;
+    status: string;
+    subscriptionId: string;
+};
+export {};