pixel-react-excel-sheet 1.2.0

package/src/components/SequentialConnectingBranch/components/Branches/Branches.scss

@@ -0,0 +1,184 @@
+@mixin arrow-style(
+  $size: 6px,
+  $color: var(--ff-connecting-branch-color),
+  $z-index: 2
+) {
+  position: absolute;
+  height: $size;
+  width: $size;
+  background-color: $color;
+  z-index: $z-index;
+}
+
+@mixin container-style(
+  $width: 100%,
+  $height: 25%,
+  $color: var(--ff-connecting-branch-color)
+) {
+  width: $width;
+  height: $height;
+  border: 1px solid $color;
+  border-top: none;
+}
+
+@mixin branch-point(
+  $size: 5px,
+  $color: var(--ff-connecting-branch-color),
+  $position: right,
+  $offset: -2px
+) {
+  position: absolute;
+  height: $size;
+  width: $size;
+  background-color: $color;
+  border-radius: 50%;
+  z-index: 2;
+  #{$position}: $offset;
+  top: calc(50% - 1px);
+}
+
+@mixin branch-arrow(
+  $clip: polygon(0 0, 0% 100%, 100% 50%),
+  $horizontal-pos: right,
+  $offset: -1px
+) {
+  position: absolute;
+  height: 5px;
+  width: 5px;
+  background-color: var(--ff-connecting-branch-color);
+  clip-path: $clip;
+  top: calc(25% - 4px);
+  #{$horizontal-pos}: $offset;
+  z-index: 2;
+}
+
+@mixin datalist-style($reverse: false) {
+  display: flex;
+  padding-top: 4px;
+  height: 24px;
+  justify-content: flex-end;
+  width: 100%;
+  align-items: center;
+  flex-direction: if($reverse, row-reverse, row);
+
+  .ff-connecting-icon {
+    margin-right: 4px;
+    cursor: pointer;
+  }
+
+  .ff-connecting-text {
+    margin-right: 8px;
+  }
+
+  .ff-connecting-delete-icon {
+    cursor: pointer;
+  }
+}
+
+@mixin end-arrow-styles($direction: right) {
+  width: 100%;
+  height: 100%;
+  margin-top: 17px;
+  border-top: 1px solid var(--ff-connecting-branch-color);
+  border-#{$direction}: 1px solid var(--ff-connecting-branch-color);
+}
+
+.ff-connecting-branch-grid,
+.ff-connecting-branch-grid-reverse {
+  box-sizing: border-box;
+  display: grid;
+  grid-template-columns: 24px 180px 40px 180px 24px;
+  height: 66px;
+  margin-bottom: 16px;
+  position: relative;
+
+  .ff-connecting-branch-start-wrapper {
+    position: relative;
+
+    .ff-connecting-branch-arrow {
+      @include arrow-style();
+      clip-path: polygon(0 0, 0% 100%, 100% 50%);
+      top: calc(25% - 3px);
+      right: -2px;
+    }
+
+    .ff-connecting-branch-arrow-reverse {
+      @include arrow-style();
+      left: -2px;
+      top: calc(25% - 3px);
+      clip-path: polygon(0 50%, 100% 100%, 100% 0);
+    }
+
+    .ff-connecting-branch-container {
+      @include container-style();
+      border-right: none;
+      border-bottom-left-radius: 8px;
+    }
+
+    .ff-connecting-branch-container-reverse {
+      @include container-style();
+      border-left: none;
+      border-bottom-right-radius: 8px;
+    }
+  }
+
+  .ff-connecting-branch-datalist {
+    @include datalist-style();
+  }
+
+  .ff-connecting-branch-datalist-reverse {
+    @include datalist-style(true);
+  }
+
+  .ff-connecting-branch-input-point-wrapper {
+    position: relative;
+
+    .ff-connecting-branch-point {
+      @include branch-point();
+    }
+
+    .ff-connecting-branch-point-reverse {
+      @include branch-point($position: left, $offset: -4px);
+    }
+  }
+
+  .ff-connecting-branch-middle-arrow {
+    height: 0px;
+    width: 100%;
+    margin-top: calc(50% - 3px);
+    position: relative;
+
+    .ff-connecting-branch-arrow {
+      @include branch-arrow();
+    }
+
+    .ff-connecting-branch-arrow-reverse {
+      @include branch-arrow(
+        $clip: polygon(0 50%, 100% 100%, 100% 0),
+        $horizontal-pos: left,
+        $offset: -1px
+      );
+    }
+  }
+
+  .ff-connecting-branch-end-arrow {
+    @include end-arrow-styles(right);
+    border-top-right-radius: 8px;
+  }
+
+  .ff-connecting-branch-end-arrow-reverse {
+    @include end-arrow-styles(left);
+    border-top-left-radius: 8px;
+  }
+
+  .ff-connecting-branch-browser-button {
+    height: 32px;
+    display: flex;
+    align-items: center;
+  }
+}
+
+.ff-connecting-branch-grid-reverse {
+  direction: rtl;
+  margin: 0px 0px 16px 0px;
+}

package/src/components/SequentialConnectingBranch/components/Branches/Branches.tsx

@@ -0,0 +1,203 @@
+import classNames from 'classnames';
+import { checkEmpty } from '../../../../utils/checkEmpty/checkEmpty';
+import { BranchesProps } from './types';
+import { Fragment } from 'react/jsx-runtime';
+import { ffid } from '../../../../utils/ffID/ffid';
+import { ExecutionContext } from '../../types';
+import MachineInputField from '../../../MachineInputField';
+import Icon from '../../../Icon';
+import Typography from '../../../Typography';
+import Button from '../../../Button';
+import './Branches.scss';
+
+const Branches = ({
+  machineInstances,
+  rowIndex,
+  machineColumnCount,
+  machineColumnWidth,
+  nextRowMachineInstance,
+  previousRowMachineInstance,
+  onAddBrowser,
+  onDeleteBrowser,
+  onAddRunBrowser,
+}: BranchesProps) => {
+  const evenRow = rowIndex % 2 === 0;
+  const lastMachineInstance = checkEmpty(
+    machineInstances[machineColumnCount - 1]
+  );
+
+  const getBorderStyle = (
+    currentBranch: ExecutionContext | {} | undefined,
+    nextBranch: ExecutionContext | {} | undefined
+  ) => {
+    if (
+      currentBranch &&
+      nextBranch &&
+      'id' in currentBranch &&
+      'id' in nextBranch
+    ) {
+      return currentBranch.id === nextBranch.id ? 'dotted' : 'solid';
+    }
+    return 'solid';
+  };
+
+  const showMiddleArrow = (index: number) =>
+    machineInstances.length - 1 !== index && machineColumnCount > 1;
+
+  const getGridTemplateColumnStyle = () => {
+    if (machineColumnCount === 1) {
+      return `24px ${machineColumnWidth}px 24px`;
+    }
+    return `24px ${machineColumnWidth}px repeat(${
+      machineColumnCount - 1
+    }, 40px ${machineColumnWidth}px) 24px`;
+  };
+
+  return (
+    <div
+      className={classNames({
+        'ff-connecting-branch-grid': evenRow,
+        'ff-connecting-branch-grid-reverse': !evenRow,
+      })}
+      style={{
+        gridTemplateColumns: getGridTemplateColumnStyle(),
+      }}
+    >
+      <div className="ff-connecting-branch-start-wrapper">
+        <div
+          className={classNames({
+            'ff-connecting-branch-arrow': evenRow,
+            'ff-connecting-branch-arrow-reverse': !evenRow,
+          })}
+        ></div>
+        <div
+          className={classNames({
+            'ff-connecting-branch-container': evenRow,
+            'ff-connecting-branch-container-reverse': !evenRow,
+          })}
+          style={{
+            border: `1px ${getBorderStyle(
+              machineInstances[0],
+              previousRowMachineInstance
+            )} var(--ff-connecting-branch-color)`,
+            borderTop: 'none',
+            borderLeft: `${!evenRow && 'none'}`,
+            borderRight: `${evenRow && 'none'}`,
+          }}
+        ></div>
+      </div>
+      {machineInstances?.map((machineInstance, index) => {
+        const {
+          executionEnv = 'Local',
+          browserName = 'Local',
+          browserVersion = '1',
+          runCount = 0,
+          id = '',
+        } = machineInstance as ExecutionContext;
+        return (
+          <Fragment key={ffid()}>
+            {!checkEmpty(machineInstance) ? (
+              <div>
+                <div className="ff-connecting-branch-input-point-wrapper">
+                  <div
+                    className={classNames({
+                      'ff-connecting-branch-point': evenRow,
+                      'ff-connecting-branch-point-reverse': !evenRow,
+                    })}
+                  ></div>
+                  <MachineInputField
+                    width={`${machineColumnWidth}px`}
+                    runCount={runCount}
+                    key={ffid()}
+                    options={[
+                      { label: executionEnv, type: executionEnv },
+                      { label: browserVersion, type: browserName },
+                    ]}
+                    contentReverse={!evenRow}
+                  />
+                </div>
+                <div
+                  className={classNames({
+                    'ff-connecting-branch-datalist': evenRow,
+                    'ff-connecting-branch-datalist-reverse': !evenRow,
+                  })}
+                >
+                  <Icon name="datalist_icon" className="ff-connecting-icon" />
+                  <Typography
+                    className="ff-connecting-text"
+                    color="var(--ff-connecting-branch-color)"
+                  >
+                    Dataset List
+                  </Typography>
+                  <Icon
+                    name="plus_icon"
+                    className="ff-connecting-icon"
+                    onClick={() => onAddRunBrowser(id)}
+                    color="var(--ff-connecting-branch-color)"
+                  />
+                  <Typography
+                    className="ff-connecting-text"
+                    color="var(--ff-connecting-branch-color)"
+                  >
+                    Run
+                  </Typography>
+                  <Icon
+                    name="delete"
+                    className="ff-connecting-delete-icon"
+                    onClick={() => onDeleteBrowser(id, runCount)}
+                    color="var(--ff-connecting-branch-delete-color)"
+                  />
+                </div>
+              </div>
+            ) : (
+              <div className="ff-connecting-branch-browser-button">
+                <Button
+                  variant="tertiary"
+                  label="Browser / Devices"
+                  onClick={onAddBrowser}
+                />
+              </div>
+            )}
+            {showMiddleArrow(index) && (
+              <div
+                className="ff-connecting-branch-middle-arrow"
+                style={{
+                  borderTop: `1px ${getBorderStyle(
+                    machineInstance,
+                    machineInstances[index + 1]
+                  )} var(--ff-connecting-branch-color)`,
+                }}
+              >
+                <div
+                  className={classNames({
+                    'ff-connecting-branch-arrow': evenRow,
+                    'ff-connecting-branch-arrow-reverse': !evenRow,
+                  })}
+                ></div>
+              </div>
+            )}
+          </Fragment>
+        );
+      })}
+      {!lastMachineInstance && (
+        <div
+          className={classNames({
+            'ff-connecting-branch-end-arrow': evenRow,
+            'ff-connecting-branch-end-arrow-reverse': !evenRow,
+          })}
+          style={{
+            border: `1px ${getBorderStyle(
+              machineInstances[machineColumnCount - 1],
+              nextRowMachineInstance
+            )} var(--ff-connecting-branch-color)`,
+            borderBottom: 'none',
+            borderLeft: `${evenRow && 'none'}`,
+            borderRight: `${!evenRow && 'none'}`,
+          }}
+        ></div>
+      )}
+    </div>
+  );
+};
+
+export default Branches;

package/src/components/SequentialConnectingBranch/components/Branches/types.ts

@@ -0,0 +1,18 @@
+import { ExecutionContext } from '../../types';
+
+export interface BranchesProps {
+  machineInstances: ExecutionContext[] | {}[];
+  rowIndex: number;
+  machineColumnCount: number;
+  machineColumnWidth: number;
+  nextRowMachineInstance?: ExecutionContext | {} | undefined;
+  previousRowMachineInstance?: ExecutionContext | {} | undefined;
+  onAddBrowser: () => void;
+  onDeleteBrowser: (id: string, runCount: number) => void;
+  onAddRunBrowser: (id: string) => void;
+}
+
+export interface branchTypeProps {
+  currentBranch: ExecutionContext | undefined | {};
+  nextBranch: ExecutionContext | undefined | {};
+}

package/src/components/SequentialConnectingBranch/components/ConnectingBranches/ConnectingBranches.scss

@@ -0,0 +1,3 @@
+.ff-connecting-branch-grid-wrapper {
+  box-sizing: border-box;
+}

package/src/components/SequentialConnectingBranch/components/ConnectingBranches/ConnectingBranches.tsx

@@ -0,0 +1,66 @@
+import { useEffect, useState } from 'react';
+import { ExecutionContext } from '../../types';
+import { ConnectingBranchesProps } from './types';
+import { Fragment } from 'react/jsx-runtime';
+import {ffid} from '../../../../utils/ffID/ffid';
+import Branches from '../Branches/Branches';
+import './ConnectingBranches.scss';
+
+const ConnectingBranches = ({
+  machineBranchInstances,
+  machineColumnCount,
+  machineColumnWidth,
+  onAddBrowser,
+  onDeleteBrowser,
+  onAddRunBrowser,
+}: ConnectingBranchesProps) => {
+  const [machineInstance, setMachineInstance] = useState<
+    ExecutionContext[] | {}[]
+  >(machineBranchInstances);
+
+  useEffect(() => {
+    setMachineInstance(machineBranchInstances);
+  }, [machineBranchInstances]);
+
+  const getMachineBranchInstancesChunk = (
+    machineBranchInstances: ExecutionContext[] | {}[],
+    chunkSize: number
+  ) => {
+    const machineBranchInstancesChunk = [];
+    for (let i = 0; i < machineBranchInstances.length; i += chunkSize) {
+      machineBranchInstancesChunk.push(
+        machineBranchInstances.slice(i, i + chunkSize)
+      );
+    }
+    return machineBranchInstancesChunk;
+  };
+
+  const machineInstancesRow = getMachineBranchInstancesChunk(
+    machineInstance,
+    machineColumnCount
+  );
+
+  return (
+    <div className="ff-connecting-branch-grid-wrapper">
+      {machineInstancesRow.map((machineInstances, index) => (
+        <Fragment key={ffid()}>
+          <Branches
+            machineInstances={machineInstances}
+            rowIndex={index}
+            machineColumnCount={machineColumnCount}
+            machineColumnWidth={machineColumnWidth}
+            onAddBrowser={onAddBrowser}
+            onDeleteBrowser={onDeleteBrowser}
+            onAddRunBrowser={onAddRunBrowser}
+            nextRowMachineInstance={machineInstancesRow[index + 1]?.[0]}
+            previousRowMachineInstance={
+              machineInstancesRow[index - 1]?.[machineColumnCount - 1]
+            }
+          />
+        </Fragment>
+      ))}
+    </div>
+  );
+};
+
+export default ConnectingBranches;

package/src/components/SequentialConnectingBranch/components/ConnectingBranches/types.ts

@@ -0,0 +1,10 @@
+import { ExecutionContext } from '../../types';
+
+export interface ConnectingBranchesProps {
+  machineBranchInstances: ExecutionContext[] | {}[];
+  machineColumnCount: number;
+  machineColumnWidth: number;
+  onAddBrowser: () => void;
+  onDeleteBrowser: (id: string, runCount: number) => void;
+  onAddRunBrowser: (id: string) => void;
+}

package/src/components/SequentialConnectingBranch/components/DatasetListModal/DatasetListModal.scss

@@ -0,0 +1,31 @@
+.ff-datalist-modal-header-wrapper,
+.ff-datalist-modal-child-wrapper,
+.ff-datalist-modal-footer-wrapper {
+  margin: 0 8px;
+}
+
+.ff-datalist-modal-header-wrapper {
+  width: 255px;
+  border-bottom: 1px solid var(--ff-connecting-branch-modal-border);
+  display: flex;
+  align-items: center;
+}
+
+.ff-datalist-modal-child-wrapper {
+  .variable {
+    margin: 8px 0;
+  }
+}
+
+.ff-datalist-modal-footer-wrapper {
+  display: flex;
+  justify-content: space-between;
+  border-top: 1px solid var(--ff-connecting-branch-modal-border);
+
+  .datalist-button-wrapper {
+    display: flex;
+    gap: 10px;
+    margin-top: 4px;
+    justify-content: flex-end;
+  }
+}

package/src/components/SequentialConnectingBranch/components/DatasetListModal/DatasetListModal.tsx

@@ -0,0 +1,85 @@
+import { forwardRef, RefObject } from 'react';
+import MiniModal from '../../../MiniModal';
+import Typography from '../../../Typography';
+import './DatasetListModal.scss';
+import Select from '../../../Select';
+import Checkbox from '../../../Checkbox';
+import Button from '../../../Button';
+import { DatasetListModalProps } from './types';
+
+const DatasetListModal = forwardRef<HTMLButtonElement, DatasetListModalProps>(
+  (props, ref) => {
+    const selectOptions = [
+      { label: 'Project Environment Variable' },
+      { label: 'Global Variables' },
+      { label: 'Test Data Set' },
+    ];
+
+    const renderSelectOptions = () =>
+      selectOptions.map(({ label }, idx) => (
+        <Select
+          key={idx}
+          optionsList={[]}
+          onChange={() => {}}
+          label={label}
+          className="variable"
+        />
+      ));
+
+    const renderFooterContent = () => (
+      <div className="ff-datalist-modal-footer-wrapper">
+        <Checkbox checked={false} label="Set as Default" />
+        <div className="datalist-button-wrapper">
+          <Button label="Cancel" variant="tertiary" />
+          <Button label="Update" variant="primary" />
+        </div>
+      </div>
+    );
+
+    return (
+      <div>
+        <MiniModal
+          anchorRef={ref as RefObject<HTMLButtonElement>}
+          headerProps={
+            <div className="ff-datalist-modal-header-wrapper">
+              <Typography
+                as="span"
+                color="var(--ff-connecting-branch-modal-header)"
+                fontWeight="semi-bold"
+                fontSize={12}
+                lineHeight="38px"
+              >
+                Data Sets
+              </Typography>
+            </div>
+          }
+          childContent={
+            <div className="ff-datalist-modal-child-wrapper">
+              {renderSelectOptions()}
+            </div>
+          }
+          footerContent={renderFooterContent()}
+          cancelButtonProps={{
+            text: 'Cancel',
+
+            // TODO: DEMO PURPOSE AND WILL BE REMOVED IN THE FUTURE
+            onClick: props?.onUpdateDatasetList,
+          }}
+          proceedButtonProps={{
+            text: 'Proceed',
+            // TODO: DEMO PURPOSE AND WILL BE REMOVED IN THE FUTURE
+            onClick: props?.onUpdateDatasetList,
+          }}
+          modalPosition="right"
+          isPopOver
+          leftTopArrow
+          extraRightSpace={{ leftTopArrow: 40 }}
+          extraLeftSpace={{ rightAlignModal: 110 }}
+          {...props}
+        />
+      </div>
+    );
+  }
+);
+
+export default DatasetListModal;

package/src/components/SequentialConnectingBranch/components/DatasetListModal/types.ts

@@ -0,0 +1,4 @@
+export interface DatasetListModalProps {
+  // TODO: DEMO PURPOSE AND WILL BE REMOVED IN THE FUTURE
+  onUpdateDatasetList: () => void;
+}

package/src/components/SequentialConnectingBranch/index.ts

@@ -0,0 +1 @@
+export { default } from './SequentialConnectingBranch';

package/src/components/SequentialConnectingBranch/types.ts

@@ -0,0 +1,42 @@
+import { Option } from '../Select/types';
+
+export interface SequentialConnectingBranchProps {
+  machineInstances?: ExecutionContext[] | {}[];
+  machineColumnWidth?: number;
+  machineColumnCount?: number;
+  machineInstance: ExecutionContext;
+  selectedMachine?: string; // TODO: type will change in the future
+  onMachineSelectionChange?: (selectedMachine: Option) => void; // TODO: function will change in the future
+  machineOptionsList?: Option[];
+}
+
+// Type for machine information
+export interface MachineInfo {
+  osName: string;
+  osVersion: string;
+  hostName: string;
+}
+
+// Type for device information
+export interface DeviceInfo {
+  // Define properties as needed; assuming it can have various structures.
+  // For example:
+  // deviceName: string;
+  // deviceType: string;
+}
+
+export interface ExecutionContext {
+  id: string;
+  clientId: string;
+  runCount: number;
+  executionEnv?: 'Local'; // Change to specific enum if more environments exist
+  browserName?: 'Local' | 'mac' | 'android' | 'Google Chrome';
+  browserVersion: string;
+  systemUrl: string;
+  machineInfo: MachineInfo;
+  deviceInfo: DeviceInfo[];
+  headless: boolean;
+  peVariableSetId: string;
+  globalVariableSetId: string;
+  testDataSetId: string;
+}