@kirill.konshin/utils 0.0.19 → 0.0.20

package/src/electron/createWindow.ts

@@ -1,234 +0,0 @@
-import path from 'node:path';
-import https from 'node:https';
-import http from 'node:http';
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import url from 'node:url';
-import { Menu, app, BrowserWindow, shell, protocol, Rectangle } from 'electron';
-import defaultMenu from 'electron-default-menu';
-import Store from 'electron-store';
-import { checkForUpdates } from './updater.js';
-
-export const isDev: boolean = process.env['NODE_ENV'] === 'development';
-export const appPath: string = app.getAppPath();
-
-// See https://cs.chromium.org/chromium/src/net/base/net_error_list.h
-const FILE_NOT_FOUND = -6;
-
-const getPath = async (path_, file = '') => {
-    try {
-        const result = await fsp.stat(path_);
-
-        if (result.isFile()) return path_;
-
-        if (result.isDirectory()) return getPath(path.join(path_, `${file}.html`));
-    } catch {
-        /* empty */
-    }
-};
-
-export function createWindow({
-    width = 1000,
-    height = 1000,
-    disableSecurity = true,
-    disableSecurityWarnings = true,
-    quitOnClose = true,
-    onOpen,
-    onClose,
-    localhostUrl = 'http://localhost:3000',
-    productionUrl = '', // in this mode Electron acts as a browser for remote app
-    webPath = path.resolve(appPath, 'web'), // must conform to what is in electron-builder.js files section
-    useStaticInDev = false,
-    updater = false,
-    rememberBounds = true,
-}: {
-    width?: number;
-    height?: number;
-    disableSecurity?: boolean;
-    disableSecurityWarnings?: boolean;
-    quitOnClose?: boolean;
-    onOpen?: (win: BrowserWindow) => void;
-    onClose?: (win: BrowserWindow) => void;
-    localhostUrl?: string;
-    productionUrl?: string;
-    webPath?: string;
-    useStaticInDev?: boolean;
-    updater?: boolean;
-    rememberBounds?: boolean;
-} = {}) {
-    let mainWindow: BrowserWindow | null = null;
-
-    console.log('[APP] Starting Electron', {
-        isDev,
-        appPath,
-        useStaticInDev,
-        localhostUrl,
-        productionUrl,
-        webPath,
-        updater,
-        rememberBounds,
-        quitOnClose,
-        disableSecurity,
-        disableSecurityWarnings,
-    });
-
-    if (!productionUrl && !webPath) {
-        throw new Error('productionUrl or webPath must be defined');
-    }
-
-    if (productionUrl && webPath) {
-        throw new Error('productionUrl and webPath cannot be used together');
-    }
-
-    if (!localhostUrl) {
-        throw new Error('localhostUrl must be defined');
-    }
-
-    const store = new Store<{ bounds: Rectangle }>({
-        schema: {
-            bounds: {
-                type: 'object',
-                properties: {
-                    // Docs: https://electronjs.org/docs/api/structures/rectangle
-                    height: { type: 'number' },
-                    width: { type: 'number' },
-                    x: { type: 'number' },
-                    y: { type: 'number' },
-                },
-            },
-        },
-    });
-
-    if (disableSecurityWarnings) process.env['ELECTRON_DISABLE_SECURITY_WARNINGS'] = 'true';
-    process.env['ELECTRON_ENABLE_LOGGING'] = 'true';
-
-    process.on('SIGTERM', () => process.exit(0));
-    process.on('SIGINT', () => process.exit(0));
-
-    const openDevTools = () => {
-        if (!mainWindow) return;
-        mainWindow.setSize(width + 800, height);
-        mainWindow.center();
-        mainWindow.webContents.openDevTools();
-    };
-
-    const createWindow = async () => {
-        mainWindow = new BrowserWindow({
-            width,
-            height,
-            icon: path.resolve(appPath, 'assets/icon.png'),
-            webPreferences: {
-                nodeIntegration: false, // is default value after Electron v5
-                contextIsolation: true, // protect against prototype pollution
-                webSecurity: !disableSecurity,
-                devTools: true,
-            },
-            ...(rememberBounds ? store.get('bounds') : {}),
-        });
-
-        mainWindow.on('move', () => rememberBounds && mainWindow && store.set('bounds', mainWindow.getBounds()));
-
-        mainWindow.once('ready-to-show', () => isDev && openDevTools());
-
-        // Static interceptor
-
-        let interceptor: (() => void) | null = null;
-
-        if (webPath && (!isDev || useStaticInDev)) {
-            console.log(`[APP] Static Server Enabled, ${localhostUrl} will be intercepted to ${webPath}`);
-
-            //TODO https://localhost:3000
-            // @see https://github.com/sindresorhus/electron-serve/blob/main/index.js
-            protocol.interceptStreamProtocol('http', (request, callback) => {
-                if (request.url.startsWith(localhostUrl)) {
-                    let fileUrl = url.parse(request.url, false).pathname;
-
-                    if (!fileUrl) return callback({ error: FILE_NOT_FOUND });
-
-                    if (fileUrl === '/') fileUrl = 'index.html';
-
-                    const filePath = path.join(webPath, fileUrl);
-
-                    const relativePath = path.relative(webPath, fileUrl);
-
-                    const isSafe = !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
-
-                    if (!isSafe && !isDev) return callback({ error: FILE_NOT_FOUND });
-
-                    // const finalPath = await getPath(filePath, options.file);
-                    // const fileExtension = path.extname(filePath);
-
-                    console.log('[APP] Static Server', fileUrl, '->', filePath);
-
-                    // return {path: path.join(webPath, fileUrl)};
-                    callback(fs.createReadStream(filePath));
-
-                    return true;
-                }
-
-                // return {url: request.url};
-                (request.url.startsWith('https') ? https : http).get(request.url, callback);
-
-                return true;
-            });
-
-            interceptor = () => protocol.uninterceptProtocol('http');
-        }
-
-        mainWindow.on('closed', () => {
-            interceptor?.();
-            onClose?.(mainWindow as never);
-            mainWindow = null;
-            interceptor = null;
-        });
-
-        // External URLs
-
-        mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-            shell.openExternal(url).catch((e) => console.error(e));
-            return { action: 'deny' };
-        });
-
-        // Menu
-
-        const menu = defaultMenu(app, shell);
-
-        if (updater) {
-            (menu.at(-1)!.submenu as any).push(
-                { type: 'separator' },
-                {
-                    label: 'Check For Updates',
-                    click: checkForUpdates,
-                },
-            );
-        }
-
-        Menu.setApplicationMenu(Menu.buildFromTemplate(menu)); //TODO onMenu
-
-        // Should be last, after all listeners and menu
-
-        await app.whenReady();
-
-        onOpen?.(mainWindow);
-
-        if (!onOpen && localhostUrl) {
-            await mainWindow.loadURL(productionUrl && !isDev ? productionUrl : `${localhostUrl}/`);
-        }
-
-        console.log('[APP] Main Window Open');
-    };
-
-    app.on('ready', createWindow);
-
-    app.on('window-all-closed', () => {
-        if (process.platform !== 'darwin' || quitOnClose) app.quit();
-    });
-
-    app.on('activate', () => BrowserWindow.getAllWindows().length === 0 && !mainWindow && createWindow());
-
-    return {
-        get mainWindow(): BrowserWindow | null {
-            return mainWindow;
-        },
-    };
-}

package/src/electron/updater.ts

@@ -1,54 +0,0 @@
-// https://github.com/electron-userland/electron-builder/blob/docs-deprecated/encapsulated%20manual%20update%20via%20menu.js
-import { dialog } from 'electron';
-import updater from 'electron-updater';
-const { autoUpdater } = updater;
-
-let updateButton;
-
-autoUpdater.autoDownload = false;
-
-autoUpdater.on('error', (error) => {
-    dialog.showErrorBox('Error: ', !error ? 'unknown' : (error.stack || error).toString());
-});
-
-autoUpdater.on('update-available', async () => {
-    const { response } = await dialog.showMessageBox({
-        type: 'info',
-        title: 'Found Updates',
-        message: 'Found updates, do you want update now?',
-        buttons: ['Yes', 'No'],
-    });
-
-    updateButton.enabled = true;
-    updateButton = null;
-
-    if (response === 0) await autoUpdater.downloadUpdate();
-});
-
-autoUpdater.on('update-not-available', async () => {
-    try {
-        await dialog.showMessageBox({
-            title: 'No Updates',
-            message: 'Current version is up-to-date.',
-        });
-    } catch (e) {
-        dialog.showErrorBox('Error: ', e.toString());
-    }
-    updateButton.enabled = true;
-    updateButton = null;
-});
-
-autoUpdater.on('update-downloaded', async () => {
-    await dialog.showMessageBox({
-        title: 'Install Update',
-        message: 'Update downloaded, application will quit for update...',
-    });
-
-    autoUpdater.quitAndInstall();
-});
-
-export function checkForUpdates(menuItem: any): void {
-    updateButton = menuItem;
-    updateButton.enabled = false;
-    autoUpdater.checkForUpdates().catch((e) => console.error('Update error', e));
-}

package/src/electron-builder/builder.ts

@@ -1,150 +0,0 @@
-import type { Configuration, MacConfiguration } from 'electron-builder';
-import type { GithubOptions, S3Options } from 'builder-util-runtime';
-
-const {
-    GITHUB_REF_TYPE,
-    GITHUB_REF_NAME,
-    GITHUB_RUN_ID,
-    GITHUB_REF,
-    AWS_URL,
-    AWS_ACCESS_KEY_ID,
-    AWS_SECRET_ACCESS_KEY,
-    GH_TOKEN,
-    CSC_IDENTITY_AUTO_DISCOVERY,
-} = process.env;
-
-const isGithubTag = GITHUB_REF_TYPE === 'tag';
-const isGithubMaster = GITHUB_REF_TYPE === 'branch' && GITHUB_REF_NAME === 'master';
-const isDevPublish = AWS_URL?.includes(':9000');
-const isNoAutoDiscovery = CSC_IDENTITY_AUTO_DISCOVERY === 'false';
-const isSkipPublish = !isDevPublish && !isGithubMaster && !isGithubTag;
-
-//FIXME Refine logic, tags should be versions, not channels, use branches? See how Changesets does it
-const channel = isGithubTag ? 'latest' : GITHUB_REF_NAME; // https://www.electron.build/tutorials/release-using-channels.html
-
-function getVersion() {
-    if (isGithubMaster) {
-        return `0.0.${GITHUB_RUN_ID}`; //TODO Figure out last normal in master and bump it
-    }
-    if (isGithubTag) {
-        return GITHUB_REF!.split('/').pop();
-    }
-    return `0.0.${Date.now()}`; //TODO Read from package.json?
-}
-
-function getTarget() {
-    const arch = ['arm64', isNoAutoDiscovery ? '' : 'x64'].filter(Boolean) as any;
-
-    const target: MacConfiguration['target'] = [
-        {
-            target: 'dmg',
-            arch,
-        },
-        {
-            target: 'zip',
-            arch,
-        },
-    ];
-
-    // Leave only DMG if no signing
-    if (isNoAutoDiscovery) {
-        console.log('Skipping signing...');
-        delete process.env.CSC_LINK;
-        return [target[0]]; // only keep DMG
-    }
-
-    return target;
-}
-
-export function builerConfig(options: {
-    config: Configuration;
-    s3?: Pick<S3Options, 'bucket'> & Partial<S3Options>; //TODO Omit?
-    githubReleases: Pick<GithubOptions, 'owner' | 'repo'> & Partial<GithubOptions>;
-}): Configuration {
-    if (options.s3 && (!AWS_URL || !AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY)) {
-        throw new Error('Missing AWS configuration');
-    }
-
-    if (options.githubReleases && !GH_TOKEN) {
-        throw new Error('Missing AWS configuration');
-    }
-
-    const config: Configuration = {
-        files: [
-            '**/*',
-            '!electron-builder.js',
-            '!electron-builder.yml',
-            '!package.json',
-            'assets',
-            ...(options.config.files as never),
-        ],
-        directories: {
-            buildResources: 'assets',
-        },
-        mac: {
-            category: options.config.mac?.category ?? 'public.app-category.utils',
-            target: getTarget(),
-        },
-        //TODO Windows target
-        dmg: {
-            contents: [
-                {
-                    x: 130,
-                    y: 130,
-                },
-                {
-                    x: 370,
-                    y: 130,
-                    type: 'link',
-                    path: '/Applications',
-                },
-            ],
-        },
-        publish: [
-            options.s3 &&
-                ({
-                    provider: 's3',
-                    endpoint: AWS_URL,
-                    channel,
-                    ...options.s3, // bucket
-                } as S3Options),
-            options.githubReleases &&
-                GH_TOKEN &&
-                (isGithubTag || isGithubMaster) &&
-                ({
-                    provider: 'github',
-                    private: true,
-                    token: GH_TOKEN,
-                    releaseType: isGithubTag ? 'release' : 'draft',
-                    channel,
-                    ...options.githubReleases, // repo, owner
-                } as GithubOptions),
-        ].filter(Boolean) as never,
-        extraMetadata: {
-            version: getVersion(),
-        },
-    };
-
-    if (isSkipPublish) {
-        delete config.publish;
-        delete (config as never as any).extraMetadata;
-    }
-
-    console.log('Electron Builder context', {
-        isDevPublish,
-        isGithubMaster,
-        isGithubTag,
-        isSkipPublish,
-        isNoAutoDiscovery,
-        channel,
-        GITHUB_RUN_ID: GITHUB_RUN_ID,
-        GITHUB_REF_TYPE: GITHUB_REF_TYPE,
-        GITHUB_REF_NAME: GITHUB_REF_NAME,
-        CSC_IDENTITY_AUTO_DISCOVERY: CSC_IDENTITY_AUTO_DISCOVERY,
-        AWS_URL: AWS_URL,
-    });
-
-    console.log('Electron Builder configuration', JSON.stringify(config, null, 2));
-
-    return config;
-}

package/src/electron-builder/images.ts

@@ -1,33 +0,0 @@
-import psd from 'psd';
-import sharp from 'sharp';
-import path from 'node:path';
-
-export async function generateImages({
-    iconPsdPath,
-    dmgBackgroundPsdPath,
-    electronAssetsPath,
-    webPublicPath,
-}: {
-    iconPsdPath: string;
-    dmgBackgroundPsdPath: string;
-    electronAssetsPath: string;
-    webPublicPath: string;
-}): Promise<void> {
-    const iconPsd = await psd.open(iconPsdPath);
-    await iconPsd.image!.saveAsPng(path.join(electronAssetsPath, 'icon.png'));
-
-    const bgPsd = await psd.open(dmgBackgroundPsdPath);
-    await bgPsd.image!.saveAsPng(path.join(electronAssetsPath, 'background@2x.png'));
-
-    const iconPng = sharp(path.join(electronAssetsPath, 'icon.png'));
-    const bgPng = sharp(path.join(electronAssetsPath, 'background@2x.png'));
-
-    await bgPng.resize(500).toFile(path.join(electronAssetsPath, 'background.png'));
-
-    await iconPng.toFile(path.join(electronAssetsPath, 'splash.webp'));
-    await iconPng.toFile(path.join(electronAssetsPath, 'icon.icns'));
-
-    //TODO Crop without icon BG
-    await iconPng.toFile(path.join(webPublicPath, 'icon.png'));
-    await iconPng.resize(32).toFile(path.join(webPublicPath, 'favicon.ico'));
-}

package/src/mui/README.md

@@ -1,3 +0,0 @@
-## Prior Art
-
-https://codesandbox.io/p/sandbox/l7vykxl57q MUI v4

package/src/mui/formControlFieldset.stories.tsx

@@ -1,71 +0,0 @@
-import React from 'react';
-import type { Meta, StoryObj } from '@storybook/react';
-
-import { TextField, Stack, InputLabel, RadioGroup, Radio, FormControlLabel, Box } from '@mui/material';
-
-import { GenericControl } from './genericControl';
-import { ReadOnly } from './readOnly';
-import { FormControlFieldset } from './formControlFieldset';
-import { FormLabelLegend } from './formLabelLegend';
-
-// More on how to set up stories at: https://storybook.js.org/docs/writing-stories#default-export
-const meta: Meta<typeof GenericControl> = {
-    title: 'MUI / FormControlFieldset',
-    parameters: {
-        layout: 'centered',
-    },
-    tags: ['autodocs'],
-    argTypes: {},
-    render: function Render() {
-        return (
-            <Box sx={{ position: 'relative' }}>
-                <Rule top={12} />
-                <Rule top={37} />
-                <Rule top={48} />
-                <Stack direction="row" gap={3} sx={{ alignItems: 'flex-start' }}>
-                    <FormControlFieldset>
-                        <FormLabelLegend>Radios</FormLabelLegend>
-                        <ReadOnly>
-                            {/* TODO The size of the component. small is equivalent to the dense radio styling. */}
-                            <RadioGroup row defaultValue="female" name="radio-buttons-group" sx={{ mt: -1 }}>
-                                <FormControlLabel value="female" label="Female" control={<Radio size="small" />} />
-                                <FormControlLabel value="male" label="Male" control={<Radio size="small" />} />
-                                <FormControlLabel value="other" label="Other" control={<Radio size="small" />} />
-                            </RadioGroup>
-                        </ReadOnly>
-                    </FormControlFieldset>
-
-                    <GenericControl>
-                        <InputLabel shrink>GenericControl</InputLabel>
-                        <ReadOnly>
-                            This is a <code>div</code>, not an input with <code>readOnly</code>
-                        </ReadOnly>
-                    </GenericControl>
-
-                    <FormControlFieldset>
-                        <FormLabelLegend>FormLabelLegend</FormLabelLegend>
-                        <ReadOnly>
-                            This is a <code>div</code>, not an input with <code>readOnly</code>
-                        </ReadOnly>
-                    </FormControlFieldset>
-
-                    <TextField label="TextField" defaultValue="Bar" variant="standard" />
-                </Stack>
-            </Box>
-        );
-    },
-} satisfies Meta<typeof GenericControl>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-function Rule({ top }) {
-    return (
-        <Box sx={{ background: 'red', position: 'absolute', left: 0, top: `${top}px`, width: '100%', height: '1px' }} />
-    );
-}
-
-export const Default: Story = {
-    args: {},
-};

package/src/mui/formControlFieldset.tsx

@@ -1,26 +0,0 @@
-import React, { FC } from 'react';
-import { GenericControl, GenericControlProps } from './genericControl';
-import { inputClasses } from '@mui/material/Input';
-
-export type FormControlFieldsetProps = GenericControlProps;
-
-export const FormControlFieldset: FC<FormControlFieldsetProps> = function FormControlFieldset({
-    children,
-    sx,
-    ...props
-}) {
-    return (
-        <GenericControl
-            {...props}
-            component="fieldset"
-            sx={{
-                ...sx,
-                [`legend + .${inputClasses.root}`]: {
-                    marginTop: 2, //FIXME 16px, hardcoded from @mui/material/Input/Input.js @ 59
-                },
-            }}
-        >
-            {children}
-        </GenericControl>
-    );
-};

package/src/mui/formLabelLegend.tsx

@@ -1,11 +0,0 @@
-import React, { FC } from 'react';
-import { default as InputLabel, InputLabelProps } from '@mui/material/InputLabel';
-
-export const FormLabelLegend: FC<InputLabelProps> = ({ children, ...props }) => {
-    return (
-        // sx={(theme) => theme.typography.caption}
-        <InputLabel {...props} shrink={true} component={'legend' as any}>
-            {children}
-        </InputLabel>
-    );
-};

package/src/mui/genericControl.tsx

@@ -1,20 +0,0 @@
-import React, { FC } from 'react';
-import { FormControlProps, default as FormControl } from '@mui/material/FormControl';
-import { inputClasses } from '@mui/material/Input';
-
-export type GenericControlProps = FormControlProps & { children: any };
-
-export const GenericControl: FC<GenericControlProps> = ({ children, sx, ...props }) => (
-    <FormControl
-        variant="standard"
-        sx={{
-            ...sx,
-            [`& .${inputClasses.root}`]: {
-                '&:before, &:after': { display: 'none' },
-            },
-        }}
-        {...props}
-    >
-        {children}
-    </FormControl>
-);

package/src/mui/readOnly.tsx

@@ -1,6 +0,0 @@
-import React, { FC } from 'react';
-import { default as Input, InputProps } from '@mui/material/Input';
-
-export const ReadOnly: FC<InputProps & { children: any }> = ({ children, inputProps, ...props }) => (
-    <Input {...props} inputComponent={'div' as any} inputProps={{ ...inputProps, children }}></Input>
-);

package/src/next/appLink.tsx

@@ -1,40 +0,0 @@
-'use client';
-
-import React, { ComponentProps, FC } from 'react';
-import { usePathname } from 'next/navigation';
-import Link, { LinkProps } from 'next/link';
-import clsx from 'clsx';
-
-//TODO Test this
-export const AppLink: FC<
-    {
-        children: any;
-        exact?: boolean;
-        activeClassName?: any;
-    } & LinkProps &
-        ComponentProps<typeof Link>
-> = function AppLink({
-    href,
-    children,
-    className = '',
-    activeClassName = '',
-    prefetch = false, // set explicit default
-    exact = false,
-    ...props
-}) {
-    const pathname = usePathname();
-    const hrefPath = typeof href === 'string' ? href : href.pathname || '/';
-
-    return (
-        <Link
-            {...props}
-            href={href}
-            className={clsx(className, {
-                [activeClassName]: (!exact && pathname.startsWith(hrefPath)) || (exact && pathname === hrefPath),
-            })}
-            prefetch={prefetch}
-        >
-            {children}
-        </Link>
-    );
-};

package/src/next/measure.ts

@@ -1,24 +0,0 @@
-import { createMeasurer } from '../core/measure';
-import { PHASE_PRODUCTION_BUILD, PHASE_PRODUCTION_SERVER } from 'next/constants';
-
-export const isProd: boolean =
-    process.env.NEXT_PHASE === PHASE_PRODUCTION_BUILD || process.env.NEXT_PHASE === PHASE_PRODUCTION_SERVER;
-
-export const measurer: {
-    measure: (
-        what: string,
-        step: string,
-        supplemental?: string,
-        ...args: any[]
-    ) => {
-        done: (result?: string, ...args2: any[]) => void;
-        fail: (result?: string, ...args2: any[]) => void;
-        log: (...args2: any[]) => void;
-    };
-    important: (str: any) => any;
-    subject: (str: any) => any;
-    arg: (str: any) => any;
-    sup: (str: any) => any;
-    ok: (str: any) => any;
-    err: (str: any) => any;
-} = createMeasurer({ colors: isProd });