@arquimedes.co/eureka-forms 3.0.71-test → 3.0.71

package/dist/FormSteps/NumberStep/MaterialNumberStep/MaterialNumberStep.module.css

@@ -0,0 +1,96 @@
+.container {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+}
+
+.inputRow {
+    display: flex;
+    align-items: flex-start;
+    gap: 12px;
+    width: 100%;
+}
+
+.selectWrapper {
+    width: 100px;
+    min-width: 90px;
+}
+
+.dividerSlash {
+    align-self: flex-start;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 40px;
+    font-size: 20px;
+    font-weight: bold;
+    color: var(--eureka-text, #333);
+    opacity: 0.6;
+    margin-left: 2px;
+    margin-right: 2px;
+}
+
+.suffixText {
+    align-self: flex-start;
+    display: flex;
+    align-items: center;
+    height: 40px;
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--eureka-primary, #1976d2);
+    padding: 0 4px;
+    user-select: none;
+}
+
+/* Read-Only Styles */
+.readOnlyContainer {
+    width: 100%;
+    margin-bottom: 8px;
+}
+
+.readOnlyCard {
+    display: flex;
+    align-items: center;
+    padding: 12px 16px;
+    border: 1px solid var(--eureka-outline, #e0e0e0);
+    border-radius: 12px;
+    background-color: var(--eureka-bg, #ffffff);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
+    transition:
+        box-shadow 0.2s ease,
+        border-color 0.2s ease;
+}
+
+.readOnlyCard:hover {
+    border-color: var(--eureka-primary, #1976d2);
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.08);
+}
+
+.readOnlyDetails {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    width: 100%;
+}
+
+.readOnlyLabel {
+    font-size: 11px !important;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    color: var(--eureka-text, #333) !important;
+    opacity: 0.6;
+    font-weight: 600 !important;
+}
+
+.readOnlyValue {
+    font-size: 16px !important;
+    font-weight: 600 !important;
+    color: var(--eureka-primary, #1976d2) !important;
+}
+
+.readOnlyDesc {
+    font-size: 12px !important;
+    color: var(--eureka-text, #333) !important;
+    opacity: 0.5;
+    margin-top: 2px !important;
+}

package/dist/FormSteps/NumberStep/NumberStep.d.ts

@@ -0,0 +1,10 @@
+import { NumberStep } from '../../@Types/FormStep';
+import { StepProps } from '../Step';
+export interface NumberStepProps extends StepProps {
+    /** The NumberStep to display */
+    step: NumberStep;
+    /** The icon to display */
+    IconComponent?: React.ElementType;
+}
+declare function NumberStepComponent(props: NumberStepProps): JSX.Element;
+export default NumberStepComponent;

package/dist/FormSteps/NumberStep/NumberStep.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FormStyleTypes } from '../../constants/FormStepTypes';
+import MaterialNumberStep from './MaterialNumberStep/MaterialNumberStep';
+import { useAppSelector } from '../../hooks';
+function NumberStepComponent(props) {
+    const { formStyle } = useAppSelector((state) => state.global);
+    switch (formStyle.type) {
+        case FormStyleTypes.MATERIAL:
+        default: {
+            return _jsx(MaterialNumberStep, { ...props });
+        }
+    }
+}
+export default NumberStepComponent;

package/dist/FormSteps/Step.js

@@ -24,6 +24,10 @@ import CustomContext from '../Contexts/CustomContext';
 import { selectOriginalValue, useCondition } from './StepHooks';
 import TimePickerStep from './TimePickerStep/TimePickerStep';
 import PhoneInputStep from './PhoneInputStep/PhoneInputStep';
+import LocationStepComponent from './LocationStep/LocationStep';
+import NumberStepComponent from './NumberStep/NumberStep';
+import BookingStepComponent from './BookingStep/BookingStep';
+import AvailabilityStepComponent from './AvailabilityStep/AvailabilityStep';
 function StepComponent({ step, ...props }) {
     const { postview, partial } = useAppSelector((state) => state.global);
     const { customSteps, customClientInfoStep } = useContext(CustomContext);
@@ -75,6 +79,18 @@ function StepComponent({ step, ...props }) {
         case FormStepTypes.DATEPICKER: {
             return _jsx(DatePickerStep, { ...props, step: step, editable: editable });
         }
+        case FormStepTypes.LOCATION: {
+            return _jsx(LocationStepComponent, { ...props, step: step, editable: editable });
+        }
+        case FormStepTypes.NUMBER: {
+            return _jsx(NumberStepComponent, { ...props, step: step, editable: editable });
+        }
+        case FormStepTypes.BOOKING: {
+            return _jsx(BookingStepComponent, { ...props, step: step, editable: editable });
+        }
+        case FormStepTypes.AVAILABILITY: {
+            return _jsx(AvailabilityStepComponent, { ...props, step: step, editable: editable });
+        }
         case FormStepTypes.DATEPICKER_RANGE: {
             return _jsx(DatePickerRangeStep, { ...props, step: step, editable: editable });
         }

package/dist/FormSteps/StepFunctions.js

@@ -1,3 +1,4 @@
+import { NumberStepType, } from '../@Types/FormStep';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueDataTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
 import CBRFormStepTypes from '../constants/CBRFormStepTypes';
 import AYFFormStepTypes from '../constants/AYFFormStepTypes';
@@ -87,6 +88,8 @@ function recursivelyCheckOpenSize(idStep, steps, values) {
             return size;
         }
         case FormStepTypes.DATEPICKER:
+        case FormStepTypes.LOCATION:
+        case FormStepTypes.NUMBER:
         case FormStepTypes.TEXTINPUT: {
             return step.size;
         }
@@ -175,6 +178,17 @@ export const calcDefaultValue = (step) => {
                 return getRawText();
             else
                 return '';
+        case FormStepTypes.LOCATION:
+            return step.defaultValue ?? null;
+        case FormStepTypes.NUMBER: {
+            const numStep = step;
+            if (numStep.numberType === NumberStepType.MONEY ||
+                numStep.numberType === NumberStepType.MEASURE ||
+                numStep.numberType === NumberStepType.UNIT_PRICE) {
+                return numStep.defaultValue ?? null;
+            }
+            return numStep.defaultValue ?? '';
+        }
         case FormStepTypes.RATING:
         case FormStepTypes.DATEPICKER:
         case FormStepTypes.DATEPICKER_RANGE:

package/dist/FormSteps/StepFunctions.test.js

@@ -1,3 +1,4 @@
+import * as Steps from '../@Types/FormStep';
 import AYFFormStepTypes from '../constants/AYFFormStepTypes';
 import CBRFormStepTypes from '../constants/CBRFormStepTypes';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, OptionTypes, } from '../constants/FormStepTypes';
@@ -527,6 +528,13 @@ describe('StepFunctions', function () {
             const defaultValue = calcDefaultValue(step);
             expect(defaultValue).toBe(null);
         });
+        test('Location step type', async () => {
+            const step = {
+                type: FormStepTypes.LOCATION,
+            };
+            const defaultValue = calcDefaultValue(step);
+            expect(defaultValue).toBe(null);
+        });
         test('Mapper, FileUpload, CBRFormStep types', async () => {
             const step1 = {
                 type: FormStepTypes.MAPPER,
@@ -558,6 +566,52 @@ describe('StepFunctions', function () {
             const defaultValue = calcDefaultValue(step);
             expect(defaultValue).toBeUndefined();
         });
+        test('Number step type without defaultValue', async () => {
+            const step1 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.INTEGER,
+            };
+            const step2 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.DECIMAL,
+            };
+            const step3 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.PERCENTAGE,
+            };
+            const step4 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MONEY,
+            };
+            const step5 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MEASURE,
+            };
+            const step6 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.UNIT_PRICE,
+            };
+            expect(calcDefaultValue(step1)).toBe('');
+            expect(calcDefaultValue(step2)).toBe('');
+            expect(calcDefaultValue(step3)).toBe('');
+            expect(calcDefaultValue(step4)).toBe(null);
+            expect(calcDefaultValue(step5)).toBe(null);
+            expect(calcDefaultValue(step6)).toBe(null);
+        });
+        test('Number step type with defaultValue', async () => {
+            const step1 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.INTEGER,
+                defaultValue: 42,
+            };
+            const step2 = {
+                type: FormStepTypes.NUMBER,
+                numberType: Steps.NumberStepType.MONEY,
+                defaultValue: { value: 100, currency: 'USD' },
+            };
+            expect(calcDefaultValue(step1)).toBe(42);
+            expect(calcDefaultValue(step2)).toEqual({ value: 100, currency: 'USD' });
+        });
     });
     describe('iterateNestedSteps', function () {
         test('should iterate over nested steps', async () => {

package/dist/FormSteps/StepHooks.d.ts

@@ -34,6 +34,13 @@ export interface StepDependency {
     handleStepDep: (value: any) => void;
 }
 export declare const useStepDependency: (step: GBaseStep, defaultValue?: any) => StepDependency;
+/**
+ * Whether `idStep` is currently kept off the form by its own visibility condition. A step that is not
+ * shown cannot be answered, so nothing may wait for it: a required entity filter pointing at it does
+ * not apply, and it never reads as a missing dependency. When the condition cannot be decided yet (a
+ * step it reads is not in the store) the step counts as shown, keeping the conservative behaviour.
+ */
+export declare const isStepHiddenByCondition: (idStep: string, form: Form, dependencies: DependencyStore) => boolean;
 export declare const selectStepDependencies: ((state: RootState, _step: GBaseStep, form: Form) => {
     invalids: string[];
     emptyDep: boolean;
@@ -67,6 +74,20 @@ export declare const selectStepDependencies: ((state: RootState, _step: GBaseSte
     memoize: typeof import("reselect").weakMapMemoize;
     argsMemoize: typeof import("reselect").weakMapMemoize;
 };
+/**
+ * The steps `idStep` depends on, transitively: every dependency's own dependencies come before it,
+ * and every id is answered exactly once. `idStep` itself is never listed — a step is not a
+ * dependency of itself, even when a draft points it back at itself.
+ *
+ * A saved form is a DAG: the backend recomputes and validates `step.dependencies` on save. The
+ * editor's live preview renders unsaved drafts though, where a filter or a path hop can still point
+ * at the step that holds it, or close a cycle with another step. The walk must therefore terminate
+ * on any graph, cyclic included: a step is marked visited before it is walked and is never walked
+ * or listed twice, so every edge is followed at most once.
+ *
+ * Exported for the unit test; it is internal to this module and not part of the package's surface.
+ */
+export declare const calcDeepDependencies: (idStep: string, form: Form) => string[];
 export interface UseFormStepOptions<ValueType> {
     defaultValue: ValueType;
     /** If true, will not trigger onChange until the user has finished typing */

package/dist/FormSteps/StepHooks.js

@@ -8,6 +8,7 @@ import { useController } from 'react-hook-form';
 import ConditionTypes from '../constants/ConditionTypes';
 import FormStepTypes, { ApiSelectorOptionTypes, ClassifierOptionTypes, EntityValueOptionTypes, } from '../constants/FormStepTypes';
 import { SizeChangeContext } from './Utils/@StepFiller/StepFillerContext';
+import { entityValuePickerBlockingSteps } from './EntityValueStep/entityValuePickerWatchedSteps';
 const selectIsDependency = createSelector([
     (state) => state.site.dependencies,
     (_state, step) => step,
@@ -47,6 +48,20 @@ export const useStepDependency = (step, defaultValue) => {
         originalValue: originalValue ?? defaultValue ?? calcDefaultValue(step),
     };
 };
+/**
+ * Whether `idStep` is currently kept off the form by its own visibility condition. A step that is not
+ * shown cannot be answered, so nothing may wait for it: a required entity filter pointing at it does
+ * not apply, and it never reads as a missing dependency. When the condition cannot be decided yet (a
+ * step it reads is not in the store) the step counts as shown, keeping the conservative behaviour.
+ */
+export const isStepHiddenByCondition = (idStep, form, dependencies) => {
+    const target = form.steps[idStep];
+    if (!target?.condition)
+        return false;
+    if (recursivelyCalcConditionSteps(target.condition).some((id) => dependencies[id] === undefined))
+        return false;
+    return !evaluateCondition(target.condition, dependencies);
+};
 export const selectStepDependencies = createSelector([
     (state) => state.site.dependencies,
     (_state, step) => step,
@@ -56,6 +71,8 @@ export const selectStepDependencies = createSelector([
     let emptyDep = false;
     /** Show deep error changes even if not in dependencies */
     for (const idDep of calcDeepDependencies(step.id, form)) {
+        if (isStepHiddenByCondition(idDep, form, dependencies))
+            continue;
         const dependency = dependencies[idDep];
         if (dependency?.value === null && form.steps[idDep]) {
             invalids.push(idDep);
@@ -65,15 +82,45 @@ export const selectStepDependencies = createSelector([
     }
     return { invalids, emptyDep };
 });
-const calcDeepDependencies = (idStep, form, deps = []) => {
-    const step = form.steps[idStep];
-    if (step?.dependencies) {
-        for (const dep of step.dependencies) {
-            if (!deps.includes(dep)) {
-                deps.push(...calcDeepDependencies(dep, form, deps), dep);
-            }
+/**
+ * The steps `idStep` depends on, transitively: every dependency's own dependencies come before it,
+ * and every id is answered exactly once. `idStep` itself is never listed — a step is not a
+ * dependency of itself, even when a draft points it back at itself.
+ *
+ * A saved form is a DAG: the backend recomputes and validates `step.dependencies` on save. The
+ * editor's live preview renders unsaved drafts though, where a filter or a path hop can still point
+ * at the step that holds it, or close a cycle with another step. The walk must therefore terminate
+ * on any graph, cyclic included: a step is marked visited before it is walked and is never walked
+ * or listed twice, so every edge is followed at most once.
+ *
+ * Exported for the unit test; it is internal to this module and not part of the package's surface.
+ */
+export const calcDeepDependencies = (idStep, form) => {
+    const deps = [];
+    /** `idStep` starts out visited so a cycle back to it stops there and never lists it. */
+    const visited = new Set([idStep]);
+    const walk = (id) => {
+        const step = form.steps[id];
+        if (!step)
+            return;
+        /**
+         * An entity picker also gives up (its options resolve to null) while a path hop or a
+         * required STEP filter holds no value. Those are in `step.dependencies` once the form has
+         * been saved, but not in an unsaved draft, so they are added here to read as a missing
+         * dependency instead of as a failed load.
+         */
+        const idDeps = step.type === FormStepTypes.ENTITYVALUEPICKER
+            ? [...(step.dependencies ?? []), ...entityValuePickerBlockingSteps(step)]
+            : step.dependencies;
+        for (const dep of idDeps ?? []) {
+            if (visited.has(dep))
+                continue;
+            visited.add(dep);
+            walk(dep);
+            deps.push(dep);
         }
-    }
+    };
+    walk(idStep);
     return deps;
 };
 export const useFormStep = (step, { rules, debounce, sizeChange, defaultValue }) => {

package/dist/FormSteps/StepHooks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/FormSteps/StepHooks.test.js

@@ -0,0 +1,92 @@
+import { describe, expect, test } from 'vitest';
+import FormStepTypes, { EntityValueDataTypes } from '../constants/FormStepTypes';
+import { calcDeepDependencies } from './StepHooks';
+const form = (steps) => ({
+    steps: Object.entries(steps).reduce((acc, [id, step]) => ({
+        ...acc,
+        [id]: { id, idSection: 'section', type: FormStepTypes.TEXTINPUT, ...step },
+    }), {}),
+});
+const picker = (step) => ({
+    type: FormStepTypes.ENTITYVALUEPICKER,
+    idEntity: 'entity',
+    path: [],
+    filters: [],
+    options: {},
+    ...step,
+});
+const stepFilter = (idStep, required) => ({
+    idProperty: 'prop-' + idStep,
+    type: EntityValueDataTypes.STEP,
+    idStep,
+    any: false,
+    required,
+});
+describe('calcDeepDependencies', () => {
+    test('walks a linear chain deepest first, listing each id once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: {},
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('lists a dependency shared by two branches once', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b', 'c'] },
+            b: { dependencies: ['d'] },
+            c: { dependencies: ['d'] },
+            d: {},
+        }));
+        expect(deps).toEqual(['d', 'b', 'c']);
+    });
+    test('terminates on an A -> B -> A cycle without listing the step itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['a'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    test('terminates on a cycle reached deeper in the walk', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['c'] },
+            c: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['c', 'b']);
+    });
+    test('terminates on a step that depends on itself', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['b'] },
+            b: { dependencies: ['b'] },
+        }));
+        expect(deps).toEqual(['b']);
+    });
+    /**
+     * A draft an entity picker points back at itself with a required STEP filter: the filter is not
+     * in the saved `dependencies` yet, so it only reaches the walk through
+     * `entityValuePickerBlockingSteps`.
+     */
+    test('terminates on a self reference through a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('picker', true)] }),
+        }));
+        expect(deps).toEqual(['picker']);
+    });
+    test('terminates on a cycle closed by a required STEP filter of an entity picker', () => {
+        const deps = calcDeepDependencies('a', form({
+            a: { dependencies: ['picker'] },
+            picker: picker({ filters: [stepFilter('other', true)] }),
+            other: { dependencies: ['picker'] },
+        }));
+        expect(deps).toEqual(['other', 'picker']);
+    });
+    test('keeps a dependency whose step the draft has already deleted', () => {
+        const deps = calcDeepDependencies('a', form({ a: { dependencies: ['gone'] } }));
+        expect(deps).toEqual(['gone']);
+    });
+    test('answers nothing for a step the form does not hold', () => {
+        expect(calcDeepDependencies('missing', form({}))).toEqual([]);
+    });
+});

package/dist/FormSteps/isStepHiddenByCondition.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/FormSteps/isStepHiddenByCondition.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'vitest';
+import { isStepHiddenByCondition } from './StepHooks';
+// A Selector shown only while the Proyecto picker holds a specific value — the shape the editor saves.
+const PROYECTO = 'ENTITYVALUEPICKER-proyecto';
+const condition = {
+    type: 'EXPRESSION',
+    expression: 'AND',
+    conditions: [
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EXISTS' },
+        { type: 'FORM_STEP', stepType: 'ENTITYVALUEPICKER', idStep: PROYECTO, operator: 'EQUAL', values: ['kai'] },
+    ],
+};
+const form = {
+    steps: {
+        [PROYECTO]: { id: PROYECTO, type: 'ENTITYVALUEPICKER' },
+        'SELECTOR-piso': { id: 'SELECTOR-piso', type: 'SELECTOR', condition },
+        'SELECTOR-libre': { id: 'SELECTOR-libre', type: 'SELECTOR' },
+    },
+};
+const dependency = (value) => ({
+    idOriginal: PROYECTO,
+    dependents: [],
+    value,
+    type: 'ENTITYVALUEPICKER',
+});
+describe('isStepHiddenByCondition', () => {
+    test('a step without condition is never hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-libre', form, {})).toBe(false);
+    });
+    test('a step whose condition evaluates false is hidden', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'otro' }) })).toBe(true);
+    });
+    test('a step whose condition evaluates true is shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, { [PROYECTO]: dependency({ _id: 'kai' }) })).toBe(false);
+    });
+    test('an undecidable condition (its step is not in the store) counts as shown', () => {
+        expect(isStepHiddenByCondition('SELECTOR-piso', form, {})).toBe(false);
+    });
+    test('a step unknown to the form counts as shown', () => {
+        expect(isStepHiddenByCondition('MAPPER-x-espacio', form, {})).toBe(false);
+    });
+});

package/dist/Icons/AddIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function AddIcon(props: IconProps): JSX.Element;
+export default AddIcon;

package/dist/Icons/AddIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function AddIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" }) }));
+}
+export default AddIcon;

package/dist/Icons/EditIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function EditIcon(props: IconProps): JSX.Element;
+export default EditIcon;

package/dist/Icons/EditIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function EditIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, version: "1.1", viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c.39-.39.39-1.02 0-1.41l-2.34-2.34c-.39-.39-1.02-.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z" }) }));
+}
+export default EditIcon;

package/dist/Icons/RemoveIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function RemoveIcon(props: IconProps): JSX.Element;
+export default RemoveIcon;

package/dist/Icons/RemoveIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function RemoveIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M19 13H5v-2h14v2z" }) }));
+}
+export default RemoveIcon;

package/dist/Icons/ViewDayIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function ViewDayIcon(props: IconProps): JSX.Element;
+export default ViewDayIcon;

package/dist/Icons/ViewDayIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function ViewDayIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M2 21h19v-2H2v2zm0-4h19v-8H2v8zm0-10h19V5H2v2z" }) }));
+}
+export default ViewDayIcon;

package/dist/Icons/ViewWeekIcon.d.ts

@@ -0,0 +1,3 @@
+import { IconProps } from './@ErkIcon';
+declare function ViewWeekIcon(props: IconProps): JSX.Element;
+export default ViewWeekIcon;

package/dist/Icons/ViewWeekIcon.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useIconProps } from './@ErkIcon';
+function ViewWeekIcon(props) {
+    const iconProps = useIconProps(props);
+    return (_jsx("svg", { ...iconProps, viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: _jsx("path", { d: "M6 5H3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm14 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1zm-7 0h-3c-.55 0-1 .45-1 1v12c0 .55.45 1 1 1h3c.55 0 1-.45 1-1V6c0-.55-.45-1-1-1z" }) }));
+}
+export default ViewWeekIcon;