xmlui 0.11.3 → 0.11.6

package/dist/scripts/src/components/TimeInput/utils.js

@@ -1,197 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormatter = getFormatter;
-exports.getNumberFormatter = getNumberFormatter;
-exports.getHours = getHours;
-exports.getMinutes = getMinutes;
-exports.getSeconds = getSeconds;
-exports.getHoursMinutes = getHoursMinutes;
-exports.getHoursMinutesSeconds = getHoursMinutesSeconds;
-exports.convert12to24 = convert12to24;
-exports.convert24to12 = convert24to12;
-exports.getAmPmLabels = getAmPmLabels;
-exports.safeMin = safeMin;
-exports.safeMax = safeMax;
-// Merged utility functions for TimeInput component
-const get_user_locale_1 = __importDefault(require("get-user-locale"));
-// ============================================================================
-// Date Formatter utilities (from dateFormatter.ts)
-// ============================================================================
-const formatterCache = new Map();
-function getFormatter(options) {
-    return function formatter(locale, date) {
-        const localeWithDefault = locale || (0, get_user_locale_1.default)();
-        if (!formatterCache.has(localeWithDefault)) {
-            formatterCache.set(localeWithDefault, new Map());
-        }
-        const formatterCacheLocale = formatterCache.get(localeWithDefault);
-        if (!formatterCacheLocale.has(options)) {
-            formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault || undefined, options).format);
-        }
-        return formatterCacheLocale.get(options)(date);
-    };
-}
-const numberFormatterCache = new Map();
-function getNumberFormatter(options) {
-    return (locale, number) => {
-        const localeWithDefault = locale || (0, get_user_locale_1.default)();
-        if (!numberFormatterCache.has(localeWithDefault)) {
-            numberFormatterCache.set(localeWithDefault, new Map());
-        }
-        const numberFormatterCacheLocale = numberFormatterCache.get(localeWithDefault);
-        if (!numberFormatterCacheLocale.has(options)) {
-            numberFormatterCacheLocale.set(options, new Intl.NumberFormat(localeWithDefault || undefined, options).format);
-        }
-        return numberFormatterCacheLocale.get(options)(number);
-    };
-}
-// ============================================================================
-// Date utilities (from dateUtils.ts)
-// ============================================================================
-function getHours(dateOrTimeString) {
-    if (!dateOrTimeString)
-        return 0;
-    if (dateOrTimeString instanceof Date) {
-        return dateOrTimeString.getHours();
-    }
-    // Handle time string format like "14:30:45" or "14:30"
-    const timeString = String(dateOrTimeString);
-    const timeParts = timeString.split(':');
-    if (timeParts.length >= 1) {
-        const hours = parseInt(timeParts[0], 10);
-        return isNaN(hours) ? 0 : hours;
-    }
-    return 0;
-}
-function getMinutes(dateOrTimeString) {
-    if (!dateOrTimeString)
-        return 0;
-    if (dateOrTimeString instanceof Date) {
-        return dateOrTimeString.getMinutes();
-    }
-    // Handle time string format like "14:30:45" or "14:30"
-    const timeString = String(dateOrTimeString);
-    const timeParts = timeString.split(':');
-    if (timeParts.length >= 2) {
-        const minutes = parseInt(timeParts[1], 10);
-        return isNaN(minutes) ? 0 : minutes;
-    }
-    return 0;
-}
-function getSeconds(dateOrTimeString) {
-    if (!dateOrTimeString)
-        return 0;
-    if (dateOrTimeString instanceof Date) {
-        return dateOrTimeString.getSeconds();
-    }
-    // Handle time string format like "14:30:45"
-    const timeString = String(dateOrTimeString);
-    const timeParts = timeString.split(':');
-    if (timeParts.length >= 3) {
-        const seconds = parseInt(timeParts[2], 10);
-        return isNaN(seconds) ? 0 : seconds;
-    }
-    return 0;
-}
-function getHoursMinutes(dateOrTimeString) {
-    if (!dateOrTimeString)
-        return '';
-    if (dateOrTimeString instanceof Date) {
-        const hours = dateOrTimeString.getHours().toString().padStart(2, '0');
-        const minutes = dateOrTimeString.getMinutes().toString().padStart(2, '0');
-        return `${hours}:${minutes}`;
-    }
-    // Handle time string - return first two components
-    const timeString = String(dateOrTimeString);
-    const timeParts = timeString.split(':');
-    if (timeParts.length >= 2) {
-        const hours = parseInt(timeParts[0], 10);
-        const minutes = parseInt(timeParts[1], 10);
-        if (!isNaN(hours) && !isNaN(minutes)) {
-            return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}`;
-        }
-    }
-    return timeString;
-}
-function getHoursMinutesSeconds(dateOrTimeString) {
-    if (!dateOrTimeString)
-        return '';
-    if (dateOrTimeString instanceof Date) {
-        const hours = dateOrTimeString.getHours().toString().padStart(2, '0');
-        const minutes = dateOrTimeString.getMinutes().toString().padStart(2, '0');
-        const seconds = dateOrTimeString.getSeconds().toString().padStart(2, '0');
-        return `${hours}:${minutes}:${seconds}`;
-    }
-    // Handle time string - ensure it has three components
-    const timeString = String(dateOrTimeString);
-    const timeParts = timeString.split(':');
-    if (timeParts.length >= 3) {
-        const hours = parseInt(timeParts[0], 10);
-        const minutes = parseInt(timeParts[1], 10);
-        const seconds = parseInt(timeParts[2], 10);
-        if (!isNaN(hours) && !isNaN(minutes) && !isNaN(seconds)) {
-            return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
-        }
-    }
-    else if (timeParts.length === 2) {
-        // Add seconds if missing
-        const hours = parseInt(timeParts[0], 10);
-        const minutes = parseInt(timeParts[1], 10);
-        if (!isNaN(hours) && !isNaN(minutes)) {
-            return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:00`;
-        }
-    }
-    return timeString;
-}
-// ============================================================================
-// Date conversion utilities (from dates.ts)
-// ============================================================================
-function convert12to24(hour12, amPm) {
-    let hour24 = Number(hour12);
-    if (amPm === 'am' && hour24 === 12) {
-        hour24 = 0;
-    }
-    else if (amPm === 'pm' && hour24 < 12) {
-        hour24 += 12;
-    }
-    return hour24;
-}
-function convert24to12(hour24) {
-    const hour12 = Number(hour24) % 12 || 12;
-    return [hour12, Number(hour24) < 12 ? 'am' : 'pm'];
-}
-// ============================================================================
-// General utilities (from utils.ts)
-// ============================================================================
-const nines = ['9', '٩'];
-const ninesRegExp = new RegExp(`[${nines.join('')}]`);
-const amPmFormatter = getFormatter({ hour: 'numeric' });
-function getAmPmLabels(locale) {
-    const amString = amPmFormatter(locale, new Date(2017, 0, 1, 9));
-    const pmString = amPmFormatter(locale, new Date(2017, 0, 1, 21));
-    const [am1, am2] = amString.split(ninesRegExp);
-    const [pm1, pm2] = pmString.split(ninesRegExp);
-    if (pm2 !== undefined) {
-        // If pm2 is undefined, nine was not found in pmString - this locale is not using 12-hour time
-        if (am1 !== pm1) {
-            return [am1, pm1].map((el) => el.trim());
-        }
-        if (am2 !== pm2) {
-            return [am2, pm2].map((el) => el.trim());
-        }
-    }
-    // Fallback
-    return ['AM', 'PM'];
-}
-function isValidNumber(num) {
-    return num !== null && num !== false && !Number.isNaN(Number(num));
-}
-function safeMin(...args) {
-    return Math.min(...args.filter(isValidNumber));
-}
-function safeMax(...args) {
-    return Math.max(...args.filter(isValidNumber));
-}

package/dist/scripts/src/components/Timer/Timer.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timerComponentRenderer = exports.TimerMd = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const renderers_1 = require("../../components-core/renderers");
-const TimerNative_1 = require("./TimerNative");
-const metadata_helpers_1 = require("../metadata-helpers");
-const COMP = "Timer";
-exports.TimerMd = (0, metadata_helpers_1.createMetadata)({
-    status: "stable",
-    description: "`Timer` is a non-visual component that fires events at regular intervals. " +
-        "It can be enabled or disabled and ensures that the timer event handler " +
-        "completes before firing the next event.",
-    props: {
-        enabled: {
-            description: "Whether the timer is enabled and should fire events.",
-            valueType: "boolean",
-            defaultValue: TimerNative_1.defaultProps.enabled,
-        },
-        interval: {
-            description: "The interval in milliseconds between timer events.",
-            valueType: "number",
-            defaultValue: TimerNative_1.defaultProps.interval,
-        },
-        initialDelay: {
-            description: "The delay in milliseconds before the first timer event.",
-            valueType: "number",
-            defaultValue: TimerNative_1.defaultProps.initialDelay,
-        },
-        once: {
-            description: "Whether the timer should stop after firing its first tick event.",
-            valueType: "boolean",
-            defaultValue: TimerNative_1.defaultProps.once,
-        },
-    },
-    events: {
-        tick: {
-            description: "This event is triggered at each interval when the ${COMP} is enabled.",
-        },
-    },
-    apis: {
-        pause: {
-            description: "Pauses the timer. The timer can be resumed later from where it left off.",
-            signature: "pause()",
-        },
-        resume: {
-            description: "Resumes a paused timer. If the timer is not paused, this method has no effect.",
-            signature: "resume()",
-        },
-        isPaused: {
-            description: "Returns whether the timer is currently paused.",
-            signature: "isPaused(): boolean",
-        },
-        isRunning: {
-            description: "Returns whether the timer is currently running (enabled and not paused).",
-            signature: "isRunning(): boolean",
-        },
-    },
-});
-exports.timerComponentRenderer = (0, renderers_1.createComponentRenderer)(COMP, exports.TimerMd, ({ node, extractValue, lookupEventHandler, registerComponentApi }) => {
-    return ((0, jsx_runtime_1.jsx)(TimerNative_1.Timer, { enabled: extractValue.asOptionalBoolean(node.props.enabled), interval: extractValue.asOptionalNumber(node.props.interval), initialDelay: extractValue.asOptionalNumber(node.props.initialDelay), once: extractValue.asOptionalBoolean(node.props.once), onTick: lookupEventHandler("tick"), registerComponentApi: registerComponentApi }));
-});

package/dist/scripts/src/components/Timer/Timer.spec.js

@@ -1,328 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const component_test_helpers_1 = require("../../testing/component-test-helpers");
-const fixtures_1 = require("../../testing/fixtures");
-fixtures_1.test.describe("Basic Functionality", () => {
-    (0, fixtures_1.test)("component renders with default props", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-enabled", "true");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-interval", "1000");
-    }));
-    (0, fixtures_1.test)("component renders with enabled=false", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" enabled="false" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-enabled", "false");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-running", "false");
-    }));
-    (0, fixtures_1.test)("component renders with custom interval", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" interval="500" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-interval", "500");
-    }));
-    (0, fixtures_1.test)("component renders with once=true", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" once="true" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-once", "true");
-    }));
-    (0, fixtures_1.test)("component renders with initial delay", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" initialDelay="500" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).toHaveAttribute("data-timer-initial-delay", "500");
-    }));
-    (0, fixtures_1.test)("component is not visible (non-visual component)", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`<Timer testId="timer" />`);
-        const timer = page.getByTestId("timer");
-        yield (0, fixtures_1.expect)(timer).not.toBeVisible();
-    }));
-});
-fixtures_1.test.describe.fixme("Event Handling", () => {
-    (0, fixtures_1.test)("timer tick event is called", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}">
-        <Timer interval="800" enabled="true" onTick="tickCount++" />
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // Wait for a few ticks
-        yield (0, fixtures_1.expect)(counter).toHaveText("0");
-        // Wait for the first tick (1000ms + some buffer)
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Wait for the second tick
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("2");
-    }));
-    (0, fixtures_1.test)("timer stops when enabled is false", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}" var.timerEnabled="{true}">
-        <Timer interval="800" enabled="{timerEnabled}" onTick="tickCount++" />
-        <Button testId="stopButton" onClick="timerEnabled = false">Stop Timer</Button>
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const stopButton = page.getByTestId("stopButton");
-        // Wait for the first tick
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Stop the timer
-        yield stopButton.click();
-        // Wait and verify it doesn't increment
-        yield page.waitForTimeout(1500);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-    }));
-    fixtures_1.test.fixme("timer prevents overlapping events", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        // This test verifies that a new tick event doesn't fire if the previous one hasn't completed
-        yield initTestBed(`
-      <Fragment var.tickStr="" var.processingTime="{2000}">
-        <Timer 
-          interval="800" 
-          enabled="true" 
-          onTick="
-            tickStr += '+';
-            delay(processingTime);
-          " 
-        />
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // First tick should start and take 2000ms to complete
-        // but interval is 1000ms, so second tick should not start until first completes
-        yield page.waitForTimeout(1500); // Wait for first tick to complete
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Wait a bit more to see if overlapping was prevented
-        yield page.waitForTimeout(1500); // Should be enough for second tick to start
-        yield (0, fixtures_1.expect)(counter).toContainText("++");
-    }));
-});
-fixtures_1.test.describe.fixme("Initial Delay Functionality", () => {
-    (0, fixtures_1.test)("timer waits for initial delay before first tick", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="">
-        <Timer interval="800" initialDelay="1600" onTick="tickStr += '+'"/>
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // Should not tick immediately
-        yield (0, fixtures_1.expect)(counter).toHaveText("");
-        // Should not tick before initial delay
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("");
-        // Should tick after initial delay
-        yield page.waitForTimeout(800); // Total 2500ms, past the 2000ms initial delay + 1000ms interval
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Should continue ticking at interval
-        yield page.waitForTimeout(800);
-        yield (0, fixtures_1.expect)(counter).toHaveText("++");
-    }));
-    (0, fixtures_1.test)("initial delay only applies to first execution, not restarts", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="" var.timerEnabled="{true}">
-        <Timer 
-          interval="400" 
-          initialDelay="800" 
-          enabled="{timerEnabled}" 
-          onTick="tickStr += '+'"
-        />
-        <Button testId="restartButton" onClick="timerEnabled = false; timerEnabled = true">Restart</Button>
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const restartButton = page.getByTestId("restartButton");
-        // Wait for initial delay + first tick
-        yield page.waitForTimeout(1300);
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Restart the timer
-        yield restartButton.click();
-        // After restart, should tick immediately without initial delay
-        yield page.waitForTimeout(500);
-        yield (0, fixtures_1.expect)(counter).toContainText("++");
-    }));
-    (0, fixtures_1.test)("initial delay works with once timer", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="">
-        <Timer interval="800" initialDelay="1600" once="true" onTick="tickStr += '+'"/>
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // Should not tick before initial delay
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("");
-        // Should tick once after initial delay
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Should not tick again
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-    }));
-});
-fixtures_1.test.describe.fixme("Pause and Resume API", () => {
-    (0, fixtures_1.test)("timer can be paused and resumed via API", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="">
-        <Timer 
-          id="myTimer"
-          interval="800" 
-          onTick="tickStr += '+'"
-        />
-        <Button testId="pauseButton" onClick="myTimer.pause()">Pause</Button>
-        <Button testId="resumeButton" onClick="myTimer.resume()">Resume</Button>
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const pauseButton = page.getByTestId("pauseButton");
-        const resumeButton = page.getByTestId("resumeButton");
-        // Wait for first tick
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Pause the timer
-        yield pauseButton.click();
-        // Should not tick while paused
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("+");
-        // Resume the timer
-        yield resumeButton.click();
-        // Should continue ticking after resume
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toContainText("++");
-    }));
-    (0, fixtures_1.test)("pause state is reset when timer is disabled", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="" var.timerEnabled="{true}">
-        <Timer 
-          id="myTimer"
-          interval="1000" 
-          enabled="{timerEnabled}"
-          onTick="tickStr += '+'"
-        />
-        <Button testId="pauseButton" onClick="myTimer.pause()">Pause</Button>
-        <Button testId="disableButton" onClick="timerEnabled = false">Disable</Button>
-        <Button testId="enableButton" onClick="timerEnabled = true">Enable</Button>
-        <Text testId="counter">{tickStr}</Text>
-        <Text testId="paused">{myTimer.isPaused() ? 'Paused' : 'Running'}</Text>
-      </Fragment>
-    `);
-        const pauseButton = page.getByTestId("pauseButton");
-        const disableButton = page.getByTestId("disableButton");
-        const enableButton = page.getByTestId("enableButton");
-        const pausedStatus = page.getByTestId("paused");
-        // Pause the timer
-        yield pauseButton.click();
-        yield (0, fixtures_1.expect)(pausedStatus).toHaveText("Paused");
-        // Disable the timer
-        yield disableButton.click();
-        // Re-enable the timer - pause state should be reset
-        yield enableButton.click();
-        yield (0, fixtures_1.expect)(pausedStatus).toHaveText("Running");
-    }));
-});
-fixtures_1.test.describe("Once Functionality", () => {
-    fixtures_1.test.fixme("timer with once=true fires only once", component_test_helpers_1.SKIP_REASON.TEST_NOT_WORKING("Waiting for timeouts are bad practice because they are flaky."), (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}">
-        <Timer interval="1000" once="true" onTick="tickCount++" />
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // Wait for the first tick
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Wait longer to ensure it doesn't tick again
-        yield page.waitForTimeout(2000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-    }));
-    fixtures_1.test.fixme("timer with once=true can be restarted by re-enabling", component_test_helpers_1.SKIP_REASON.TEST_NOT_WORKING("Waiting for timeouts are bad practice because they are flaky."), (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}" var.timerEnabled="{true}">
-        <Timer interval="1000" once="true" enabled="{timerEnabled}" onTick="tickCount++" />
-        <Button testId="restartButton" onClick="timerEnabled = false; timerEnabled = true">Restart</Button>
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const restartButton = page.getByTestId("restartButton");
-        // Wait for the first tick
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Restart the timer
-        yield restartButton.click();
-        // Wait for another tick
-        yield page.waitForTimeout(1200);
-        yield (0, fixtures_1.expect)(counter).toHaveText("2");
-    }));
-    fixtures_1.test.fixme("once timer doesn't interfere with regular timer functionality", component_test_helpers_1.SKIP_REASON.TEST_NOT_WORKING("Waiting for timeouts are bad practice because they are flaky."), (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickStr="">
-        <Timer interval="1000" once="false" onTick="tickStr += '+'" />
-        <Text testId="counter">{tickStr}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        // Wait for multiple ticks
-        yield page.waitForTimeout(2000);
-        yield (0, fixtures_1.expect)(counter).toContainText("+");
-    }));
-});
-fixtures_1.test.describe.fixme("State Management", () => {
-    (0, fixtures_1.test)("timer can be dynamically enabled and disabled", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}" var.timerEnabled="{false}">
-        <Timer interval="800" enabled="{timerEnabled}" onTick="tickCount++" />
-        <Button testId="startButton" onClick="timerEnabled = true">Start Timer</Button>
-        <Button testId="stopButton" onClick="timerEnabled = false">Stop Timer</Button>
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const startButton = page.getByTestId("startButton");
-        const stopButton = page.getByTestId("stopButton");
-        // Initially disabled - should not increment
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("0");
-        // Start the timer
-        yield startButton.click();
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Stop the timer again
-        yield stopButton.click();
-        const currentCount = yield counter.textContent();
-        yield page.waitForTimeout(1000);
-        yield (0, fixtures_1.expect)(counter).toHaveText(currentCount || "1");
-    }));
-    (0, fixtures_1.test)("timer interval can be changed dynamically", (_a) => __awaiter(void 0, [_a], void 0, function* ({ page, initTestBed }) {
-        yield initTestBed(`
-      <Fragment var.tickCount="{0}" var.timerInterval="{2000}">
-        <Timer interval="{timerInterval}" enabled="true" onTick="tickCount++" />
-        <Button testId="fasterButton" onClick="timerInterval = 500">Faster</Button>
-        <Text testId="counter">{tickCount}</Text>
-      </Fragment>
-    `);
-        const counter = page.getByTestId("counter");
-        const fasterButton = page.getByTestId("fasterButton");
-        // Start with 2000ms interval
-        yield page.waitForTimeout(2500);
-        yield (0, fixtures_1.expect)(counter).toHaveText("1");
-        // Change to 500ms interval
-        yield fasterButton.click();
-        yield page.waitForTimeout(1500); // Should get multiple ticks quickly
-        const finalCount = parseInt((yield counter.textContent()) || "0");
-        (0, fixtures_1.expect)(finalCount).toBeGreaterThan(1);
-    }));
-});