xettri

FlowEngine Implementation Example

Below is the TypeScript class implementation for managing a flat, normalized state architecture for a visual flow builder. It demonstrates how to initialize the normalized dictionaries and perform operations in $O(1)$ time.

// 1. Define Entity Interfaces / Classes
class FlowNode {
  id: string;
  label: string;
  type: string;

xettri

// extended version of header for response header with toJSON feature
class ResponseHeader extends Headers {
  #jsonHeader: Record<string, string> | null = null;
  constructor(init?: HeadersInit) {
    super(init);
  }
  toJSON(): Record<string, string> {
    // if header already parsed then return cached value
    if (this.#jsonHeader) return this.#jsonHeader;
    const result: Record<string, string> = {};

xettri

// Solution 1 without regex

function isLowerAlpha(char) {
    return /^[a-z]+$/.test(char);
}

function getWordPos(word, text) {
    for (var i = 0; i <= text.length - word.length; i++) {
        if (text.substr(i, word.length) === word) {
            if (i === 0 || !isLowerAlpha(text.charAt(i - 1))) {

xettri

import React from 'react';

export type ExtendHTMLProps<P extends object = {}> = Merge<React.HTMLAttributes<HTMLElement>, P>;
export type Merge<A, B> = Omit<A, keyof B> & B;

type ExtendAs<C extends React.ElementType = 'div'> = {
  as?: C;
};

export type PolymorphicExtendedProps<

xettri

export const uploadFile = ({
  api,
  fileId,
  payload,
  onSuccess: _onSuccess,
  onProgress: _onProgress,
  onError: _onError,
  onAbort: _onAbort,
  abortMaker,
}) => {

xettri

const http = require("http");
const https = require("https");

// Ignore SSL error
process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";

const createProxyServer = ({ url, headers, responseHeaders } = {}) => {
  let forwardUrl;
  try {
    forwardUrl = new URL(url);

xettri

/**
 * Uploads a file using XMLHttpRequest with progress, error, and abort handling.
 *
 * @param {Object} options - The options for the file upload.
 * @param {string} options.api - The API endpoint for the file upload.
 * @param {File} options.file - The File object to be uploaded.
 * @param {string} options.type - The MIME type of the file.
 * @param {string} [options.method="PUT"] - The HTTP method for the request.
 * @param {function} [options.onProgress] - A callback function to handle upload progress.
 * @param {function} [options.onError] - A callback function to handle upload errors.

xettri

const webpack = require("webpack");
const { RawSource } = require("webpack-sources");

class DynamicLoadScript {
  constructor(options = { filename: "bundle.js" }) {
    this.options = options;
  }
  apply(compiler) {
    compiler.hooks.thisCompilation.tap("DynamicLoadScript", (compilation) => {
      compilation.hooks.processAssets.tapPromise(

xettri

const { deepEqual } = require('assert');

Object.defineProperty(Object.prototype, 'deepEqual', {
  writable: false,
  enumerable: false,
  configurable: false,
  value: (a, b) => deepEqual(a, b),
})

// Usage:

xettri

{
  "extends": [
    "react-app",
    "eslint:recommended",
    "plugin:react/recommended",
    "plugin:react-hooks/recommended",
    "prettier"
  ],
  "plugins": ["react", "import"],
  "parserOptions": {