incyclist-services 1.1.86 → 1.1.87

package/lib/routes/base/types/index.d.ts

@@ -120,3 +120,6 @@ export interface Parser<In, Out extends RouteBase> {
     supportsContent(data: In): boolean;
     getData(info: FileInfo, data?: In): Promise<In>;
 }
+export interface AppStatus {
+    isOnline?: boolean;
+}

package/lib/routes/list/cards/ActiveImportCard.d.ts

@@ -4,7 +4,8 @@ import { ImportFilter } from "../../../base/cardlist/types";
 import { PromiseObserver } from "../../../base/types/observer";
 import { Route } from "../../base/model/route";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType, ActiveImportProps } from "./types";
+import { RouteCardType, ActiveImportProps } from "./types";
+import { AppStatus } from "../../base/types";
 export declare class ActiveImportCard extends BaseCard implements Card<Route> {
     protected file: FileInfo;
     protected error: Error;

package/lib/routes/list/cards/FreeRideCard.d.ts

@@ -5,7 +5,8 @@ import { LatLng } from "../../../utils/geo";
 import { Route } from "../../base/model/route";
 import { FreeRideOption } from "../types";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType } from "./types";
+import { RouteCardType } from "./types";
+import { AppStatus } from "../../base/types";
 export type FreeRideSettings = {
     position?: LatLng;
     options?: any;

package/lib/routes/list/cards/RouteCard.d.ts

@@ -2,9 +2,10 @@ import { Card, CardList } from "../../../base/cardlist";
 import { Observer, PromiseObserver } from "../../../base/types/observer";
 import { RouteApiDetail } from "../../base/api/types";
 import { Route } from "../../base/model/route";
-import { RouteInfo } from "../../base/types";
+import { RouteInfo, RoutePoint } from "../../base/types";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType } from "./types";
+import { RouteCardType } from "./types";
+import { AppStatus } from "../../base/types";
 import { RouteStartSettings } from "../types";
 import { RoutesDbLoader } from "../loaders/db";
 import { DownloadObserver } from "../../download/types";
@@ -28,8 +29,15 @@ export interface StartSettings {
     realityFactor: number;
     downloadProgress?: number;
     convertProgress?: number;
+    loopOverwrite?: boolean;
+    nextOverwrite?: boolean;
 }
 export type RouteSettings = StartSettings & RouteStartSettings;
+export type RouteCardProps = {
+    settings: RouteSettings;
+    showLoopOverwrite: boolean;
+    showNextOverwrite: boolean;
+};
 declare class ConvertObserver extends Observer {
     protected conversion: Observer;
     constructor();
@@ -65,10 +73,11 @@ export declare class RouteCard extends BaseCard implements Card<Route> {
     getCardType(): RouteCardType;
     getTitle(): string;
     getDisplayProperties(): SummaryCardDisplayProps;
+    getMarkers(settings?: RouteSettings): Array<RoutePoint>;
     getId(): string;
     enableDelete(enabled?: boolean): void;
     canDelete(): boolean;
-    openSettings(): RouteSettings;
+    openSettings(): RouteCardProps;
     changeSettings(props: RouteSettings): void;
     save(): Promise<void>;
     delete(): PromiseObserver<boolean>;
@@ -102,5 +111,6 @@ export declare class RouteCard extends BaseCard implements Card<Route> {
     protected resetDownload(): Promise<void>;
     protected deleteRoute(): Promise<void>;
     protected logError(err: Error, fn: string): void;
+    protected getSettings(): RouteSettings;
 }
 export {};

package/lib/routes/list/cards/RouteCard.js

@@ -22,6 +22,7 @@ const utils_1 = require("../../../utils");
 const service_2 = require("../../download/service");
 const localization_1 = require("../../base/utils/localization");
 const gd_eventlog_1 = require("gd-eventlog");
+const route_1 = require("../../base/utils/route");
 class ConvertObserver extends observer_1.Observer {
     constructor() {
         super();
@@ -162,6 +163,19 @@ class RouteCard extends base_1.BaseCard {
             this.logError(err, 'getDisplayProperties');
         }
     }
+    getMarkers(settings) {
+        const markers = [];
+        try {
+            const startSettings = settings || this.getSettings();
+            const startDistance = startSettings.startPos || 0;
+            const startPos = (0, route_1.getPosition)(this.route, { distance: startDistance, nearest: true });
+            markers.push(startPos);
+        }
+        catch (err) {
+            this.logError(err, 'getMarkers');
+        }
+        return markers;
+    }
     getId() {
         var _a, _b;
         return (_b = (_a = this.route) === null || _a === void 0 ? void 0 : _a.description) === null || _b === void 0 ? void 0 : _b.id;
@@ -173,32 +187,29 @@ class RouteCard extends base_1.BaseCard {
         return this.deleteable;
     }
     openSettings() {
-        this.startSettings = { startPos: 0, realityFactor: 100, type: this.getCardType() };
+        var _a, _b, _c, _d, _e, _f;
+        const settings = this.getSettings();
+        let showLoopOverwrite, showNextOverwrite;
         try {
-            let migrate = false;
-            const legacy = this.buildSettingsKey(true);
-            const legacySettings = (0, settings_1.useUserSettings)().get(legacy, null);
-            if (legacySettings) {
-                this.startSettings = legacySettings;
-                migrate = true;
-            }
-            const key = this.buildSettingsKey();
-            const startSettings = (0, settings_1.useUserSettings)().get(key, null);
-            if (startSettings) {
-                this.startSettings = startSettings;
-            }
-            if (migrate) {
-                (0, settings_1.useUserSettings)().set(key, this.startSettings);
+            showLoopOverwrite = (_b = (_a = this.route) === null || _a === void 0 ? void 0 : _a.description) === null || _b === void 0 ? void 0 : _b.isLoop;
+            showNextOverwrite = (0, valid_1.valid)((_d = (_c = this.route) === null || _c === void 0 ? void 0 : _c.description) === null || _d === void 0 ? void 0 : _d.next);
+            if (showNextOverwrite) {
+                const card = (0, service_1.getRouteList)().getCard((_f = (_e = this.route) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.next);
+                const route = card === null || card === void 0 ? void 0 : card.getData();
+                if (!route || (route.description.requiresDownload && !route.description.isDownloaded)) {
+                    showNextOverwrite = false;
+                }
+                console.log('~~~ NEXT', route);
             }
         }
         catch (err) {
             this.logError(err, 'openSettings');
         }
-        return this.startSettings;
+        return { settings, showLoopOverwrite, showNextOverwrite };
     }
     changeSettings(props) {
         try {
-            this.startSettings = props;
+            this.startSettings = Object.assign({}, props);
             const userSettings = (0, settings_1.useUserSettings)();
             const key = this.buildSettingsKey();
             userSettings.set(key, props, true);
@@ -275,6 +286,7 @@ class RouteCard extends base_1.BaseCard {
     start() {
         try {
             const service = (0, service_1.getRouteList)();
+            console.log('~~~ start', this.startSettings);
             service.select(this.route);
             service.setStartSettings(Object.assign({ type: this.getCardType() }, this.startSettings));
             this.route.description.tsLastStart = Date.now();
@@ -519,5 +531,29 @@ class RouteCard extends base_1.BaseCard {
     logError(err, fn) {
         this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
     }
+    getSettings() {
+        this.startSettings = { startPos: 0, realityFactor: 100, type: this.getCardType() };
+        try {
+            let migrate = false;
+            const legacy = this.buildSettingsKey(true);
+            const legacySettings = (0, settings_1.useUserSettings)().get(legacy, null);
+            if (legacySettings) {
+                this.startSettings = legacySettings;
+                migrate = true;
+            }
+            const key = this.buildSettingsKey();
+            const startSettings = (0, settings_1.useUserSettings)().get(key, null);
+            if (startSettings) {
+                this.startSettings = startSettings;
+            }
+            if (migrate) {
+                (0, settings_1.useUserSettings)().set(key, this.startSettings);
+            }
+        }
+        catch (err) {
+            this.logError(err, 'getSettings');
+        }
+        return this.startSettings;
+    }
 }
 exports.RouteCard = RouteCard;

package/lib/routes/list/cards/RouteImportCard.d.ts

@@ -3,7 +3,8 @@ import { ImportFilter } from "../../../base/cardlist/types";
 import { PromiseObserver } from "../../../base/types/observer";
 import { Route } from "../../base/model/route";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType, RouteImportProps } from "./types";
+import { RouteCardType, RouteImportProps } from "./types";
+import { AppStatus } from "../../base/types";
 export declare class RouteImportCard extends BaseCard implements Card<Route> {
     setVisible(): void;
     canStart(status: AppStatus): boolean;

package/lib/routes/list/cards/types.d.ts

@@ -17,6 +17,3 @@ export interface ActiveImportProps {
     visible: boolean;
     observer: Observer;
 }
-export interface AppStatus {
-    isOnline?: boolean;
-}

package/lib/routes/list/service.d.ts

@@ -61,7 +61,7 @@ export declare class RouteListService extends IncyclistService {
     onCarouselUpdated(list: any, item: any, itemsInSlide: any): void;
     preload(): PromiseObserver<void>;
     getLists(forUi?: boolean): Array<CardList<Route>>;
-    getRouteDetails(id: string): Promise<RouteApiDetail>;
+    getRouteDetails(id: string, expectLocal?: boolean): Promise<RouteApiDetail>;
     getSelectedRouteDetails(): Promise<RouteApiDetail>;
     unselect(): void;
     select(route: Route): void;

package/lib/routes/list/service.js

@@ -300,11 +300,13 @@ let RouteListService = (() => {
                 return [this.myRoutes];
             }
         }
-        getRouteDetails(id) {
+        getRouteDetails(id, expectLocal = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
                     const route = this.routes.find(r => r.description.id === id);
                     if (route) {
+                        if (expectLocal && route.description.requiresDownload && !route.description.isDownloaded)
+                            return;
                         if (route.details)
                             return route.details;
                         route.details = yield this.db.getDetails(id);

package/lib/workouts/base/model/Segment.d.ts

@@ -0,0 +1,18 @@
+import Step from './Step';
+import { CurrentStep, SegmentDefinition, StepDefinition } from './types';
+export default class Segment extends Step implements SegmentDefinition {
+    steps: Array<Step>;
+    repeat: number;
+    constructor(opts?: SegmentDefinition, ignoreValidate?: boolean);
+    protected init(opts: SegmentDefinition, ignoreValidate: boolean): void;
+    validate(): void;
+    validateTiming(): boolean;
+    prepareNext(json: StepDefinition | SegmentDefinition): void;
+    push(s: any): void;
+    getDuration(): number;
+    getSingleDuration(): number;
+    getStart(): number;
+    getEnd(): number;
+    getStep(ts: number): Step;
+    getLimits(ts: any, includeStepInfo?: boolean): CurrentStep;
+}

package/lib/workouts/base/model/Segment.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const valid_1 = require("../../../utils/valid");
+const Step_1 = __importDefault(require("./Step"));
+class Segment extends Step_1.default {
+    constructor(opts = null, ignoreValidate) {
+        super(opts, true);
+        this.steps = [];
+        this.repeat = 1;
+        this.type = 'segment';
+        if ((0, valid_1.valid)(opts)) {
+            this.init(opts, ignoreValidate);
+            if (ignoreValidate === undefined || ignoreValidate === false)
+                this.validate();
+        }
+    }
+    init(opts, ignoreValidate) {
+        const start = opts.start || 0;
+        this.start = start;
+        let stepStart = start;
+        if (opts instanceof Step_1.default) {
+            this.steps = [new Step_1.default(opts)];
+        }
+        else if (opts.steps !== undefined) {
+            if (Array.isArray(opts.steps)) {
+                opts.steps.forEach(step => {
+                    if (step.start === undefined) {
+                        step.start = stepStart;
+                    }
+                    const s = new Step_1.default(step);
+                    stepStart = s.end;
+                    this.steps.push(s);
+                });
+            }
+            else {
+                if (ignoreValidate !== true)
+                    throw new Error(`Invalid Segment description, no steps defined`);
+            }
+        }
+        else {
+            if (ignoreValidate === undefined || ignoreValidate === false)
+                throw new Error(`Invalid Segment description, no steps defined`);
+        }
+        if (opts.repeat !== undefined)
+            this.repeat = opts.repeat;
+        this.duration = this.getDuration();
+        this.end = this.start + this.duration;
+    }
+    validate() {
+        this.validateTiming();
+    }
+    validateTiming() {
+        let prev;
+        this.steps.forEach(s => {
+            s.validateTiming();
+            if (prev !== undefined) {
+                const delta1 = Math.abs(prev.end - s.start);
+                if (delta1 > 0)
+                    throw new Error(`Invalid Segment description, start & prev end not matching`);
+            }
+            prev = s;
+        });
+        return true;
+    }
+    prepareNext(json) {
+        if (json === undefined)
+            return;
+        const empty = this.steps.length === 0;
+        if (json.start === undefined && json.end === undefined) {
+            json.start = !empty ? this.steps[this.steps.length - 1].end : 0;
+        }
+        if (empty) {
+            this.start = 0;
+        }
+    }
+    push(s) {
+        if (s === undefined)
+            return;
+        this.prepareNext(s);
+        let step;
+        if (s instanceof Step_1.default || s instanceof Segment)
+            step = s;
+        else
+            step = new Step_1.default(s);
+        this.steps.push(step);
+        this.duration += step.getDuration();
+        this.end = this.start + this.duration;
+        this.validate();
+    }
+    getDuration() {
+        return this.getSingleDuration() * this.repeat;
+    }
+    getSingleDuration() {
+        if (this.steps.length === 0)
+            return 0;
+        return this.steps.map(s => s.duration).reduce((a, b) => a + b);
+    }
+    getStart() {
+        if (this.start !== undefined)
+            return this.start;
+        else {
+            if (this.steps.length > 0)
+                return this.steps[0].start;
+            else
+                return undefined;
+        }
+    }
+    getEnd() {
+        return this.getStart() + this.getDuration();
+    }
+    getStep(ts) {
+        if (ts >= this.getStart() && ts <= this.getEnd()) {
+            const segTime = ts - this.getStart();
+            let part = (segTime % this.getSingleDuration());
+            part += this.getStart();
+            if (part === this.getStart() && segTime > 0)
+                part += this.getSingleDuration();
+            const found = this.steps.find(s => {
+                return (part >= s.start && part <= s.end);
+            });
+            return found;
+        }
+    }
+    getLimits(ts, includeStepInfo = false) {
+        const step = this.getStep(ts);
+        if (step === undefined)
+            return undefined;
+        const segTime = ts - this.getStart();
+        let part = (segTime % this.getSingleDuration());
+        part += this.getStart();
+        if (part === this.getStart() && segTime > 0)
+            part += this.getSingleDuration();
+        return step.getLimits(part, includeStepInfo);
+    }
+}
+exports.default = Segment;

package/lib/workouts/base/model/Step.d.ts

@@ -0,0 +1,35 @@
+import { CurrentStep, Limit, PowerLimit, StepDefinition } from "./types";
+export declare const STEP_TYPE: {
+    STEP: string;
+    SEGMENT: string;
+};
+export declare const POWER_TYPE: {
+    WATT: string;
+    PCT: string;
+};
+export default class Step implements StepDefinition {
+    type: 'step' | 'segment';
+    start?: number;
+    end?: number;
+    duration: number;
+    power?: PowerLimit;
+    cadence?: Limit;
+    hrm?: Limit;
+    text: string;
+    work: boolean;
+    steady: boolean;
+    cooldown: boolean;
+    constructor(opts?: any, ignoreValidate?: boolean);
+    validate(): void;
+    getDuration(): number;
+    getStart(): number;
+    getEnd(): number;
+    validateTiming(): boolean;
+    validateLimit(p: Limit, name: string): boolean;
+    validatePower(): boolean;
+    validateCadence(): boolean;
+    validateHrm(): boolean;
+    getLimits(ts: number, includeStepInfo?: boolean): CurrentStep;
+    getRemainder(limits: CurrentStep, includeStepInfo?: boolean): CurrentStep;
+    calc(ts: any, limit: any, includeStepInfo: boolean, isPower?: boolean): {};
+}

package/lib/workouts/base/model/Step.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POWER_TYPE = exports.STEP_TYPE = void 0;
+const clone_1 = __importDefault(require("../../../utils/clone"));
+const valid_1 = require("../../../utils/valid");
+exports.STEP_TYPE = {
+    STEP: 'step',
+    SEGMENT: 'segment'
+};
+exports.POWER_TYPE = {
+    WATT: 'watt',
+    PCT: 'pct of FTP'
+};
+class Step {
+    constructor(opts, ignoreValidate) {
+        const { start, end, duration, power, cadence, hrm, text, work, steady, cooldown } = opts || {};
+        const numVal = (s) => typeof (s) === 'string' ? Number(s) : s;
+        this.type = 'step';
+        this.start = ((0, valid_1.valid)(start)) ? numVal(start) : undefined;
+        this.end = ((0, valid_1.valid)(end)) ? numVal(end) : undefined;
+        this.duration = ((0, valid_1.valid)(duration)) ? numVal(duration) : 0;
+        this.cadence = (0, valid_1.valid)(cadence) ? (0, clone_1.default)(cadence) : undefined;
+        this.power = (0, valid_1.valid)(power) ? (0, clone_1.default)(power) : undefined;
+        this.hrm = (0, valid_1.valid)(hrm) ? (0, clone_1.default)(hrm) : undefined;
+        this.text = text || '';
+        this.work = (0, valid_1.valid)(work) ? work : false;
+        this.steady = (0, valid_1.valid)(steady) ? steady : true;
+        this.cooldown = (0, valid_1.valid)(cooldown) ? cooldown : false;
+        if (ignoreValidate === undefined || ignoreValidate === false)
+            this.validate();
+    }
+    validate() {
+        this.validateTiming();
+        this.validatePower();
+        this.validateCadence();
+        this.validateHrm();
+    }
+    getDuration() { return this.duration; }
+    getStart() { return this.start; }
+    getEnd() { return this.end; }
+    validateTiming() {
+        if (this.start === undefined && this.end === undefined) {
+            throw new Error(`Invalid Step description, start or end needs to be provided `);
+        }
+        else if (this.start !== undefined && this.end === undefined) {
+            this.end = this.start + this.duration;
+            return true;
+        }
+        else if (this.start === undefined && this.end !== undefined) {
+            this.start = this.end - this.duration;
+            return true;
+        }
+        else if (this.start !== undefined && this.end !== undefined && this.duration === 0) {
+            this.duration = this.end - this.start;
+            if (this.duration < 0)
+                throw new Error(`Invalid Step description, duration:${this.duration} `);
+            return true;
+        }
+        else {
+            const delta = Math.abs(this.duration - (this.end - this.start));
+            if (delta > 0)
+                throw new Error(`Invalid step description, duration does not match start and end `);
+            return true;
+        }
+    }
+    validateLimit(p, name) {
+        if ((0, valid_1.valid)(p)) {
+            if (p.min === undefined && p.max === undefined)
+                throw new Error(`Invalid Step description, ${name}: no values specified`);
+            if (p.min !== undefined && p.max !== undefined && p.min > p.max)
+                throw new Error(`Invalid Step description, min ${name} > max ${name}`);
+            if (p.min !== undefined && p.min < 0)
+                throw new Error(`Invalid Step description, min ${name} <0`);
+            if (p.max !== undefined && p.max < 0)
+                throw new Error(`Invalid Step description, max ${name} <0`);
+        }
+        return true;
+    }
+    validatePower() {
+        if ((0, valid_1.valid)(this.power)) {
+            const p = this.power;
+            if (p.type === undefined)
+                p.type = 'watt';
+            return this.validateLimit(p, 'power');
+        }
+        return true;
+    }
+    validateCadence() {
+        return this.validateLimit(this.cadence, 'cadence');
+    }
+    validateHrm() {
+        return this.validateLimit(this.hrm, 'hrm');
+    }
+    getLimits(ts, includeStepInfo = false) {
+        const rv = (limits) => this.getRemainder(limits, includeStepInfo);
+        if (ts >= this.start && ts <= this.end) {
+            const duration = this.duration;
+            const remaining = this.end - ts;
+            if (this.steady) {
+                const { power, cadence, hrm, text, work } = this;
+                return rv({ power, cadence, hrm, text, work, duration, remaining });
+            }
+            else {
+                const { text, work } = this;
+                const power = this.calc(ts, this.power, includeStepInfo, true);
+                const cadence = this.calc(ts, this.cadence, includeStepInfo);
+                const hrm = this.calc(ts, this.hrm, includeStepInfo);
+                return rv({ power, cadence, hrm, text, work, duration, remaining });
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    getRemainder(limits, includeStepInfo = false) {
+        if (limits === undefined)
+            return;
+        if (includeStepInfo)
+            limits.step = this;
+        return limits;
+    }
+    calc(ts, limit, includeStepInfo, isPower = false) {
+        if (!limit)
+            return ({});
+        const type = isPower ? limit.type : undefined;
+        const rv = (limits) => this.getRemainder(isPower ? Object.assign(Object.assign({}, limits), { type }) : limits, includeStepInfo);
+        const part = (ts - this.start) / this.duration;
+        if (limit !== undefined) {
+            if (limit.max === undefined && limit.min === undefined) {
+                return rv({});
+            }
+            let min, max;
+            if (this.cooldown) {
+                if (limit.max === undefined && limit.min !== undefined) {
+                    return rv({ min: limit.min });
+                }
+                max = limit.min !== undefined ? limit.max - part * (limit.max - limit.min) : limit.max - part * (limit.max);
+                min = isPower ? max : limit.min;
+            }
+            else {
+                if (limit.max === undefined && limit.min !== undefined) {
+                    return rv({ min: limit.min });
+                }
+                if (limit.min === undefined && limit.max !== undefined) {
+                    return rv({ max: limit.max });
+                }
+                max = min = limit.max !== undefined ? part * (limit.max - limit.min) + limit.min : limit.max;
+                min = isPower ? max : limit.min;
+            }
+            limit = { min, max };
+        }
+        return rv(limit);
+    }
+}
+exports.default = Step;

package/lib/workouts/base/model/Workout.d.ts

@@ -0,0 +1,10 @@
+import Segment from './Segment';
+import { Category, SegmentDefinition, StepDefinition, WorkoutDefinition } from './types';
+export default class Workout extends Segment implements WorkoutDefinition {
+    name: string;
+    description: string;
+    category: Category;
+    constructor(opts: WorkoutDefinition);
+    addStep(step: StepDefinition): void;
+    addSegment(segment: SegmentDefinition): void;
+}

package/lib/workouts/base/model/Workout.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Step_1 = __importDefault(require("./Step"));
+const Segment_1 = __importDefault(require("./Segment"));
+const valid_1 = require("../../../utils/valid");
+class Workout extends Segment_1.default {
+    constructor(opts) {
+        super(opts, true);
+        this.name = opts.name || '';
+        this.description = opts.description || undefined;
+        this.category = (0, valid_1.valid)(opts.category) ? Object.assign({}, opts.category) : undefined;
+        this.repeat = 1;
+    }
+    addStep(step) {
+        if ((0, valid_1.valid)(step)) {
+            if (step.duration === undefined && step.start === undefined && step.end === undefined)
+                throw new Error(`Invalid Step description, start&end or duration needs to be provided `);
+            this.prepareNext(step);
+            if (step instanceof Step_1.default)
+                this.push(step);
+            else {
+                const s = new Step_1.default(step);
+                this.push(s);
+            }
+        }
+    }
+    addSegment(segment) {
+        if ((0, valid_1.valid)(segment)) {
+            this.prepareNext(segment);
+            if (segment instanceof Segment_1.default)
+                this.push(segment);
+            else {
+                const s = new Segment_1.default(segment);
+                this.push(s);
+            }
+        }
+    }
+}
+exports.default = Workout;