@blueprintui/cli 0.11.4 → 0.13.0

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-number/element.d.ts

@@ -0,0 +1,39 @@
+import { LitElement } from 'lit';
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/format-number.js';
+ * ```
+ *
+ * ```html
+ * <bp-format-number></bp-format-number>
+ * ```
+ *
+ * @summary The format-datetime component is used to display numbers in a human-readable format. The element reflects the [Intl.NumberFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) API.
+ * @element bp-format-number
+ * @since 1.17.0
+ */
+export declare class BpFormatNumber extends LitElement {
+    #private;
+    /** Defines the number formatting style, such as currency, decimal, or percent */
+    accessor format: 'currency' | 'decimal' | 'percent';
+    /** Specifies the currency code to use for currency formatting */
+    accessor currency: string;
+    /** Specifies the locales to use for number formatting */
+    accessor locales: string[];
+    /** Controls how to display the currency sign in accounting or standard format */
+    accessor currencySign: 'standard' | 'accounting';
+    /** Controls how the currency is displayed, as symbol, code, or name */
+    accessor currencyDisplay: 'symbol' | 'code' | 'name';
+    /** Controls how compact notation displays, using short or long forms */
+    accessor compactDisplay: 'short' | 'long';
+    /** Controls how units are displayed in formatted numbers */
+    accessor unitDisplay: 'long' | 'short' | 'narrow';
+    /** Defines the number notation style, such as standard, scientific, or compact */
+    accessor notation: 'standard' | 'scientific' | 'engineering' | 'compact';
+    /** Controls when to display the sign for positive and negative numbers */
+    accessor signDisplay: 'auto' | 'never' | 'always' | 'exceptZero';
+    private accessor value;
+    static styles: CSSStyleSheet[];
+    render(): import("lit").TemplateResult<1>;
+    connectedCallback(): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-number/element.js

@@ -0,0 +1,62 @@
+import { __decorate } from "tslib";
+import { html, LitElement } from 'lit';
+import { baseStyles, interactionTextChange } from '@blueprintui/components/internals';
+import styles from './element.css' with { type: 'css' };
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/format-number.js';
+ * ```
+ *
+ * ```html
+ * <bp-format-number></bp-format-number>
+ * ```
+ *
+ * @summary The format-datetime component is used to display numbers in a human-readable format. The element reflects the [Intl.NumberFormat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat) API.
+ * @element bp-format-number
+ * @since 1.17.0
+ */
+let BpFormatNumber = class BpFormatNumber extends LitElement {
+    static { this.properties = {
+        format: { type: String },
+        currency: { type: String },
+        locales: { type: Array },
+        currencySign: { type: String, attribute: 'currency-sign' },
+        currencyDisplay: { type: String, attribute: 'currency-display' },
+        compactDisplay: { type: String, attribute: 'compact-display' },
+        unitDisplay: { type: String, attribute: 'unit-display' },
+        notation: { type: String },
+        signDisplay: { type: String, attribute: 'sign-display' },
+        value: { state: true }
+    }; }
+    constructor() {
+        super(...arguments);
+        /** Defines the number formatting style, such as currency, decimal, or percent */
+        this.format = 'decimal';
+        this.value = 0;
+    }
+    static { this.styles = [baseStyles, styles]; }
+    get #value() {
+        return new Intl.NumberFormat(this.locales, {
+            style: this.currency ? 'currency' : this.format,
+            notation: this.notation,
+            currency: this.currency,
+            currencySign: this.currencySign,
+            currencyDisplay: this.currencyDisplay,
+            compactDisplay: this.compactDisplay,
+            unitDisplay: this.unitDisplay,
+            signDisplay: this.signDisplay
+        }).format(this.value);
+    }
+    render() {
+        return html ` <data value=${this.value} part="internal">${this.#value}</data> `;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.value = parseFloat(this.textContent);
+        this.addEventListener('bp-textchange', () => (this.value = parseFloat(this.textContent)));
+    }
+};
+BpFormatNumber = __decorate([
+    interactionTextChange()
+], BpFormatNumber);
+export { BpFormatNumber };

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-number/index.d.ts

@@ -0,0 +1 @@
+export * from './element.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-number/index.js

@@ -0,0 +1 @@
+export * from './element.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-relative-time/element.d.ts

@@ -0,0 +1,34 @@
+import { LitElement } from 'lit';
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/format-relative-time.js';
+ * ```
+ *
+ * ```html
+ * <bp-format-relative-time>2024-11-16T10:30:00Z</bp-format-relative-time>
+ * ```
+ *
+ * @summary The format-relative-time component displays relative time (e.g., "2 hours ago", "in 3 days") using the Intl.RelativeTimeFormat API.
+ * @element bp-format-relative-time
+ * @since 2.10.0
+ */
+export declare class BpFormatRelativeTime extends LitElement {
+    #private;
+    /** determines how to format the time: 'auto' shows "yesterday" vs "1 day ago" */
+    accessor numeric: 'always' | 'auto';
+    /** determines the formatting style: 'long', 'short', or 'narrow' */
+    accessor formatStyle: 'long' | 'short' | 'narrow';
+    /** the time unit to use, or 'auto' to automatically select the best unit */
+    accessor unit: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year' | 'auto';
+    /** auto-update the displayed time at appropriate intervals */
+    accessor sync: boolean;
+    /** locale to use for formatting */
+    accessor locale: string;
+    private accessor _value;
+    private accessor _now;
+    static styles: CSSStyleSheet[];
+    render(): import("lit").TemplateResult<1>;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    updated(changedProperties: Map<string, any>): void;
+}

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-relative-time/element.js

@@ -0,0 +1,216 @@
+import { __decorate } from "tslib";
+import { html, LitElement } from 'lit';
+import { baseStyles, interactionTextChange } from '@blueprintui/components/internals';
+import styles from './element.css' with { type: 'css' };
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/format-relative-time.js';
+ * ```
+ *
+ * ```html
+ * <bp-format-relative-time>2024-11-16T10:30:00Z</bp-format-relative-time>
+ * ```
+ *
+ * @summary The format-relative-time component displays relative time (e.g., "2 hours ago", "in 3 days") using the Intl.RelativeTimeFormat API.
+ * @element bp-format-relative-time
+ * @since 2.10.0
+ */
+let BpFormatRelativeTime = class BpFormatRelativeTime extends LitElement {
+    static { this.properties = {
+        numeric: { type: String },
+        formatStyle: { type: String, attribute: 'format-style' },
+        unit: { type: String },
+        sync: { type: Boolean },
+        locale: { type: String },
+        _value: { state: true },
+        _now: { state: true }
+    }; }
+    constructor() {
+        super(...arguments);
+        /** determines how to format the time: 'auto' shows "yesterday" vs "1 day ago" */
+        this.numeric = 'auto';
+        /** determines the formatting style: 'long', 'short', or 'narrow' */
+        this.formatStyle = 'long';
+        /** the time unit to use, or 'auto' to automatically select the best unit */
+        this.unit = 'auto';
+        /** auto-update the displayed time at appropriate intervals */
+        this.sync = false;
+        this._value = '';
+        this._now = Date.now();
+    }
+    #syncInterval = null;
+    static { this.styles = [baseStyles, styles]; }
+    get #relativeTime() {
+        try {
+            const date = new Date(this._value);
+            if (isNaN(date.getTime())) {
+                console.warn('bp-format-relative-time: Invalid date value', this._value);
+                return '';
+            }
+            const diffMs = date.getTime() - this._now;
+            const diffSec = Math.round(diffMs / 1000);
+            const diffMin = Math.round(diffMs / 60000);
+            const diffHour = Math.round(diffMs / 3600000);
+            const diffDay = Math.round(diffMs / 86400000);
+            const diffWeek = Math.round(diffMs / 604800000);
+            const diffMonth = Math.round(diffMs / 2629800000); // average month
+            const diffYear = Math.round(diffMs / 31557600000); // average year
+            let value;
+            let selectedUnit;
+            if (this.unit !== 'auto') {
+                selectedUnit = this.unit;
+                switch (this.unit) {
+                    case 'second':
+                        value = diffSec;
+                        break;
+                    case 'minute':
+                        value = diffMin;
+                        break;
+                    case 'hour':
+                        value = diffHour;
+                        break;
+                    case 'day':
+                        value = diffDay;
+                        break;
+                    case 'week':
+                        value = diffWeek;
+                        break;
+                    case 'month':
+                        value = diffMonth;
+                        break;
+                    case 'year':
+                        value = diffYear;
+                        break;
+                    default:
+                        value = diffSec;
+                        selectedUnit = 'second';
+                }
+            }
+            else {
+                // Auto-select the most appropriate unit
+                if (Math.abs(diffYear) >= 1) {
+                    value = diffYear;
+                    selectedUnit = 'year';
+                }
+                else if (Math.abs(diffMonth) >= 1) {
+                    value = diffMonth;
+                    selectedUnit = 'month';
+                }
+                else if (Math.abs(diffWeek) >= 1) {
+                    value = diffWeek;
+                    selectedUnit = 'week';
+                }
+                else if (Math.abs(diffDay) >= 1) {
+                    value = diffDay;
+                    selectedUnit = 'day';
+                }
+                else if (Math.abs(diffHour) >= 1) {
+                    value = diffHour;
+                    selectedUnit = 'hour';
+                }
+                else if (Math.abs(diffMin) >= 1) {
+                    value = diffMin;
+                    selectedUnit = 'minute';
+                }
+                else {
+                    value = diffSec;
+                    selectedUnit = 'second';
+                }
+            }
+            const formatter = new Intl.RelativeTimeFormat(this.locale, {
+                numeric: this.numeric,
+                style: this.formatStyle
+            });
+            return formatter.format(value, selectedUnit);
+        }
+        catch (error) {
+            console.error('bp-format-relative-time: Error formatting relative time', error);
+            return '';
+        }
+    }
+    get #updateInterval() {
+        if (this.unit !== 'auto') {
+            switch (this.unit) {
+                case 'second':
+                    return 1000; // 1 second
+                case 'minute':
+                    return 60000; // 1 minute
+                case 'hour':
+                    return 3600000; // 1 hour
+                case 'day':
+                case 'week':
+                case 'month':
+                case 'year':
+                    return 86400000; // 1 day
+                default:
+                    return 60000;
+            }
+        }
+        // Auto mode: determine interval based on time difference
+        try {
+            const date = new Date(this._value);
+            if (isNaN(date.getTime()))
+                return 60000;
+            const diffMs = Math.abs(date.getTime() - this._now);
+            const diffMin = diffMs / 60000;
+            const diffHour = diffMs / 3600000;
+            const diffDay = diffMs / 86400000;
+            if (diffMin < 1) {
+                return 1000; // Update every second for recent times
+            }
+            else if (diffHour < 1) {
+                return 60000; // Update every minute for times within an hour
+            }
+            else if (diffDay < 1) {
+                return 3600000; // Update every hour for times within a day
+            }
+            else {
+                return 86400000; // Update every day for older times
+            }
+        }
+        catch {
+            return 60000; // Default to 1 minute
+        }
+    }
+    render() {
+        return html `<time part="internal" datetime=${this._value}>${this.#relativeTime}</time>`;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this._value = this.textContent?.trim() || '';
+        this._now = Date.now();
+        this.addEventListener('bp-textchange', () => {
+            this._value = this.textContent?.trim() || '';
+            this._now = Date.now();
+        });
+        this.#setupSync();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.#clearSync();
+    }
+    updated(changedProperties) {
+        super.updated(changedProperties);
+        if (changedProperties.has('sync') || changedProperties.has('unit')) {
+            this.#setupSync();
+        }
+    }
+    #setupSync() {
+        this.#clearSync();
+        if (this.sync) {
+            this.#syncInterval = window.setInterval(() => {
+                this._now = Date.now();
+            }, this.#updateInterval);
+        }
+    }
+    #clearSync() {
+        if (this.#syncInterval !== null) {
+            clearInterval(this.#syncInterval);
+            this.#syncInterval = null;
+        }
+    }
+};
+BpFormatRelativeTime = __decorate([
+    interactionTextChange()
+], BpFormatRelativeTime);
+export { BpFormatRelativeTime };

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-relative-time/index.d.ts

@@ -0,0 +1 @@
+export * from './element.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-relative-time/index.js

@@ -0,0 +1 @@
+export * from './element.js';

package/src/.rollup.cache/@blueprintui/components/Users/coryrylan/Repos/blueprint/blueprint/topic-update-cli/projects/components/dist/format-token/element.d.ts

@@ -0,0 +1,32 @@
+import { LitElement, PropertyValues } from 'lit';
+/**
+ * ```typescript
+ * import '@blueprintui/components/include/format-token.js';
+ * ```
+ *
+ * ```html
+ * <bp-format-token format="word-piece">Hello world!</bp-format-token>
+ * ```
+ *
+ * @summary The format token component visualizes text tokenization for language models, displaying how text is split into tokens using various tokenization strategies like WordPiece, BPE, SentencePiece, and LLaMA.
+ * @element bp-format-token
+ * @since 2.8.0
+ * @slot - Provide text content to be tokenized
+ * @cssprop --padding
+ * @cssprop --border-radius
+ * @cssprop --border
+ * @cssprop --font-family
+ * @cssprop --line-height
+ * @cssprop --gap
+ */
+export declare class BpFormatToken extends LitElement {
+    #private;
+    static styles: CSSStyleSheet[];
+    /** Specifies the tokenization strategy used to split text into tokens for language model visualization */
+    accessor format: 'bpe' | 'word-piece' | 'sentence-piece' | 'llama' | 'character' | 'whitespace';
+    private accessor _text;
+    get tokens(): string[];
+    render(): import("lit").TemplateResult<1>;
+    updated(props: PropertyValues<this>): void;
+    connectedCallback(): void;
+}