@fusion.dev/helix-core 0.58.1 → 0.59.1

package/dist/utils/value-as/value-as.d.ts

@@ -35,6 +35,26 @@ export declare const valueAsTime: (value: string) => Date | null;
  * format change dressed as a conversion.
  */
 export declare const timeAsValue: (date: Date | null) => string;
+/**
+ * The minutes since midnight an `HH:mm` value names, or `null`.
+ *
+ * **Minute precision, which is narrower than `valueAsTime` above and is meant
+ * to be.** That one takes seconds because `<input type="time">` does at a step
+ * below a minute. This library's time controls have no such step: theirs is in
+ * minutes and floored at one, so nothing they offer or write ever carries a
+ * second, and a value that did would lose it here silently. Two readings of one
+ * string, and a control picks the one it can hold.
+ */
+export declare const valueAsMinutes: (value: string) => number | null;
+/**
+ * Minutes since midnight as `HH:mm`, wrapping rather than running off the day.
+ *
+ * A step past midnight is the next morning, which is what a list of offered
+ * times does at its end and what an arrow key does at either.
+ */
+export declare const minutesAsValue: (minutes: number) => string;
+/** Whether a value is a time these controls can hold, which is minute precision. */
+export declare const isTimeValue: (value: string) => boolean;
 /**
  * The number a value holds, or `NaN`.
  *

package/dist/utils/value-as/value-as.js

@@ -41,5 +41,17 @@ export const timeAsValue = (date) => {
     const hm = `${pad(clock.getUTCHours())}:${pad(clock.getUTCMinutes())}`;
     return seconds === 0 ? hm : `${hm}:${pad(clock.getUTCSeconds())}`;
 };
+export const valueAsMinutes = (value) => {
+    const parts = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value);
+    if (!parts) {
+        return null;
+    }
+    return Number(parts[1]) * 60 + Number(parts[2]);
+};
+export const minutesAsValue = (minutes) => {
+    const whole = ((Math.round(minutes) % 1440) + 1440) % 1440;
+    return `${String(Math.floor(whole / 60)).padStart(2, '0')}:${String(whole % 60).padStart(2, '0')}`;
+};
+export const isTimeValue = (value) => valueAsMinutes(value) !== null;
 export const valueAsNumber = (value) => value.trim() === '' ? Number.NaN : Number(value);
 export const numberAsValue = (count) => (Number.isNaN(count) ? '' : String(count));

package/dist/utils/write-time/write-time.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A time written the way the reader's locale writes one.
+ *
+ * `Intl` decides between a twelve and a twenty-four hour clock, because that is
+ * a property of the locale rather than of any component: `en-US` gets `2:30 PM`
+ * and `en-GB` gets `14:30` without either being configured. There is no flag to
+ * force one, deliberately. A product that needs to override its reader's own
+ * convention has a locale problem rather than a component one, and the value is
+ * 24 hour regardless.
+ *
+ * A value this cannot read is handed back unchanged, so a field showing what is
+ * being typed shows the letters rather than blanking under the reader.
+ */
+export declare const writeTime: (value: string, locale?: string) => string;

package/dist/utils/write-time/write-time.js

@@ -0,0 +1,12 @@
+import { valueAsMinutes } from '../value-as/value-as.js';
+export const writeTime = (value, locale) => {
+    const minutes = valueAsMinutes(value);
+    if (minutes === null) {
+        return value;
+    }
+    const at = new Date(Date.UTC(2000, 0, 1, Math.floor(minutes / 60), minutes % 60));
+    return new Intl.DateTimeFormat(locale || undefined, {
+        timeStyle: 'short',
+        timeZone: 'UTC',
+    }).format(at);
+};

package/dist/utils/written-list/written-list.d.ts

@@ -21,3 +21,16 @@
  * resolve an id nobody can write.
  */
 export declare const writtenList: (source: string | undefined) => string[];
+/**
+ * The same list read as numbers, with everything that is not one dropped.
+ *
+ * **A stray entry leaves rather than becoming `NaN`.** A comparison against
+ * `NaN` is false in both directions and a `NaN` drawn is nothing at all, so one
+ * mistyped bound in `thresholds="0, 1, x, 6"` would color cells by a rule no
+ * reader can see. Dropped, the rest of the list still means what it says.
+ *
+ * **Which numbers count is the caller's question.** Finiteness is all this can
+ * answer, because a number that makes sense here is a bound, a reading and a
+ * playback rate, and only the caller knows that a rate of zero is not a rate.
+ */
+export declare const writtenNumbers: (source: string | undefined) => number[];

package/dist/utils/written-list/written-list.js

@@ -1 +1,4 @@
 export const writtenList = (source) => (source ?? '').split(/[\s,]+/).filter((one) => one !== '');
+export const writtenNumbers = (source) => writtenList(source)
+    .map(Number)
+    .filter((one) => Number.isFinite(one));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.58.1",
+  "version": "0.59.1",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -34,12 +34,13 @@
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.58.1"
+    "@fusion.dev/helix-icons": "0.59.1"
   },
   "devDependencies": {
     "@custom-elements-manifest/analyzer": "^0.11.0",
-    "@fusion.dev/helix-cem": "0.58.1",
-    "@fusion.dev/helix-testing": "0.58.1",
+    "@fusion.dev/helix-cem": "0.59.1",
+    "@fusion.dev/helix-testing": "0.59.1",
+    "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },
   "homepage": "https://fusion.dev",