JavaScript Password Brute Force

 function hasStringSimilarCharacters (string) {

    for (var characterIndex in string) {

        if (

            characterIndex > 0 &&

            string[characterIndex] === string[characterIndex - 1]

        ) {

            return true;

        }

    }

    return false;

}

function bruteForce (parameters) {

    var currentPassword = parameters.startPasswordPrefix || '';

    var filterSimilarCharacters = parameters.filterSimilarCharacters || false;

    var totalPasswordLength = parameters.totalPasswordLength;

    var charactersThatCanBeInPassword = parameters.charactersThatCanBeInPassword;

    var doOnEveryStep = parameters.doOnEveryStep;

    var doOnEnd = parameters.doOnEnd;

    if (

        doOnEveryStep &&

        currentPassword.length <= totalPasswordLength

    ) {

        doOnEveryStep(currentPassword);

    }

    if (currentPassword.length >= totalPasswordLength) {

        return [currentPassword];

    }

    var passwords = [currentPassword];

    for (var characterIndex in charactersThatCanBeInPassword) {

        var nextPassword = currentPassword + charactersThatCanBeInPassword[characterIndex];

        if (filterSimilarCharacters && hasStringSimilarCharacters(nextPassword)) {

            continue;

        }

        var nextParameters = {

            totalPasswordLength: totalPasswordLength,

            startPasswordPrefix: nextPassword,

            charactersThatCanBeInPassword: charactersThatCanBeInPassword,

            filterSimilarCharacters: filterSimilarCharacters,

            doOnEveryStep: doOnEveryStep

        };

        passwords = passwords.concat(bruteForce(nextParameters));

    }

    if (doOnEnd) {

        doOnEnd(passwords);

    }

    return passwords;

}

function isPasswordCorrect (password) {

    if (password === 'MyPassWord12') {

        return true;

    } else {

        return false;

    }

}

var startPasswordPrefix = 'MyPassWord';

var allPasswords = bruteForce({

    totalPasswordLength: startPasswordPrefix.length + 2,

    startPasswordPrefix: startPasswordPrefix,

    charactersThatCanBeInPassword: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],

    doOnEveryStep: function (password) {

        if (isPasswordCorrect(password)) {

            console.log('Correct password: ' + password);

        }

    }

});

console.log(allPasswords);

Detect file encoding UTF-8 or Windows-1251

Install or copy: https://www.npmjs.com/package/detect-character-encoding

Code:

const fs = require('fs');

const path = require('path');

const languageEncoding = require('./Detect-File-Encoding-and-Language-main');

const folderPath = path.resolve('C:/path/to/folder/src');

function walkDirAndGetFileEncoding (folderPath) {

    fs.readdirSync(folderPath).forEach(function (filesOrFolder) {

        const fileOrFolderPath = path.join(folderPath, filesOrFolder);

        const stats = fs.statSync(fileOrFolderPath);

        if (stats.isDirectory()) {

            walkDirAndGetFileEncoding(fileOrFolderPath);

        } else if (stats.isFile()) {

            languageEncoding(fileOrFolderPath).then(function (fileInfo) {

                if (fileInfo.encoding !== 'UTF-8') {

                    console.log(fileInfo.encoding + ' ' + fileOrFolderPath);

                }

            });

        }

    });

}

walkDirAndGetFileEncoding(folderPath);

React Scroll to bottom

 export const configMenuInitialState: ConfigMenuStateInterface = {

    isConfirmMenuVisible: false

};

export function EventsHistoryConfigMenu (): JSX.Element {

    const {

        configMenu: {

            isConfirmMenuVisible

        }

    } = useReduxState('configMenu');

    

    const configMenuRef: React.MutableRefObject<HTMLDivElement> = useRef<HTMLDivElement>(null);

    return (

        <>

            <div ref={configMenuRef} className={styles['config-menu']}></div>

            {

                isConfirmMenuVisible && (

                    <div className={styles['confirm-menu']}></div>

                    <ScrollToBottom configMenuRef={configMenuRef} />

                )

            }

        </>

    );

}

export function openConfirmMenuAction () {

    return function (dispatch: Dispatch<any>): void {

        dispatch(setConfigConfirmMenuScrollToBottomActive(true));

        dispatch(setConfigConfirmMenuVisibility(true));

    };

}

interface ScrollToBottomProps {

    configMenuRef: React.MutableRefObject<HTMLDivElement>;

}

function ScrollToBottom (props: ScrollToBottomProps): null {

    const {

        configMenu: {

            isScrollToBottomActive

        }

    } = useReduxState('configMenu');

    const dispatch = useDispatch();

    useEffect(function (): () => void {

        if (isScrollToBottomActive) {

            const sectionElement: any = props.configMenuRef?.current?.parentNode?.parentNode?.parentNode?.parentNode?.parentNode;

            if (sectionElement) {

                sectionElement.scrollTop = sectionElement.scrollHeight;

            }

        }

        return function onUnmount (): void {

            dispatch(setScrollToBottomActive(false));

        };

    }, []);

    return null;

}

Регулярное выражение - аналог \w с учетом русских символов

В JavaScript регулярное выражение \w соответствует только латинским буквам, цифрам и символу подчеркивания. Оно не включает в себя русские буквы или другие символы, не относящиеся к латинскому алфавиту.

Это связано с тем, что JavaScript использует стандартные регулярные выражения, основанные на стандарте Unicode Regular Expressions. В этом стандарте символ \w соответствует только латинским буквам, цифрам и символу подчеркивания.

Если вам нужно учитывать русские буквы в регулярных выражениях в JavaScript, вы можете использовать символьные классы Unicode. Например, вы можете использовать [\p{L}\p{N}_] для соответствия любой букве, цифре или символу подчеркивания, включая и русские буквы.

При этом буква "ё" на MacOS не равна букве ё в Windows.

MacOS сохраняет кириллическую "ё", как 2 символа.

Поэтому с учетом всех особенностей составляем регулярное выражение - аналог \w с учетом русских символов: 

/^[-_(),.\sa-zа-яЯ̆ёёЁ\d]+$/i

React Hook Portal

 import React, {useEffect, useRef} from 'react';

import ReactDOM from 'react-dom';

interface Props {

    children: React.ReactNode;

}

export function Portal (props: Props): JSX.Element {

    const container: React.MutableRefObject<HTMLDivElement> = useRef<HTMLDivElement>(document.createElement('div'));

    useEffect(function (): () => void {

        document.body.appendChild(container.current);

        const elementForRemoval: HTMLDivElement = container.current;

        return function (): void {

            document.body.removeChild(elementForRemoval);

        };

    }, [container]);

    return ReactDOM.createPortal(props.children, container.current);

}

interface DialogProps {

    open: boolean;

    children?: React.ReactNode;

}

export function Dialog (props: DialogProps): JSX.Element {

    if (props.open) {

        return (

            <Portal>

                <div>{props.children}</div>

            </Portal>

        );

    } else {

        return null;

    }

}

React Hook Disable parent DIV click

 import React, {useState} from 'react';

const [mouseButtonDownTime, setMouseButtonDownTime] = useState<Date>(null);

function handleSetMouseButtonDownTime (event: React.MouseEvent<HTMLDivElement>): void {

    if (event.button === 0) {

        setMouseButtonDownTime(new Date());

    }

}

function hasParent (child): boolean {

    let node = child.parentNode;

    while (node !== null) {

        if (node.classList && node.classList.contains('disabled-parent-click')) {

            return true;

        }

        node = node.parentNode;

    }

    return false;

}

function handleParentDivClick (message: string): (event: React.MouseEvent<HTMLDivElement>) => void {

    return function (event: React.MouseEvent<HTMLDivElement>): void {

        if (

            event.button === 0 &&

            mouseButtonDownTime !== null &&

            (new Date().getTime() - mouseButtonDownTime.getTime() < 200)

        ) {

            if (hasParent(event.target)) {

                return;

            }

            console.log(message);

        }

    };

}

function handleChildDivClick (): void {

    console.log('Child DIV click.');

}

return  (

    <div onMouseDown={handleSetMouseButtonDownTime} onMouseUp={handleParentDivClick('Parent DIV click.')}>   

        <span>Parent DIV.</span>

        <div className={'disabled-parent-click'} onClick={handleChildDivClick}>Child DIV.</div>

    </div>

);

React Hook useReduxState

 /* eslint-disable react-hooks/rules-of-hooks */

import {useSelector} from 'react-redux';

import get from 'lodash-es/get';

import {RootStateInterface} from './interfaces';

type RootStateKey = keyof RootStateInterface;

type StateKeyWithDots = `.${string}`;

export type RootOrDotsStateKey = RootStateKey | StateKeyWithDots;

interface SelectedStateInterface extends Partial<RootStateInterface> {

    [key: StateKeyWithDots]: any;

}

export function useReduxState (firstStateKey: RootOrDotsStateKey, ...stateKeys: RootOrDotsStateKey[]): SelectedStateInterface {

    stateKeys.push(firstStateKey);

    const selectedState: SelectedStateInterface = {};

    stateKeys.forEach(function (stateKey: RootOrDotsStateKey): void {

        selectedState[stateKey] = useSelector(function (state: RootStateInterface): any {

            if (stateKey.indexOf('.') === 0) {

                return get(state, stateKey.slice(1));

            }

            return state[stateKey];

        });

    });

    return selectedState;

}

    const {

       projectData: {

            value: projectDataValue

        },

        clusterSelect: {

            value: custerValue

        }

        '.buildVersion.ui.requestData': uiVersion

    } = useReduxState(

        'projectsData',

        'clusterSelect',

        'buildVersion'

    );