@expcat/tigercat-vue 1.1.0 → 1.2.14

package/dist/chunk-5JKQPOG2.js

@@ -0,0 +1,133 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/NumberKeyboard.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var NumberKeyboard = _vue.defineComponent.call(void 0, {
+  name: "TigerNumberKeyboard",
+  inheritAttrs: false,
+  props: {
+    modelValue: { type: String, default: void 0 },
+    defaultValue: { type: String, default: "" },
+    mode: { type: String, default: "number" },
+    maxLength: { type: Number, default: void 0 },
+    precision: { type: Number, default: void 0 },
+    decimalSeparator: { type: String, default: "." },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    confirmText: { type: String, default: "Done" },
+    deleteText: { type: String, default: "Delete" },
+    ariaLabel: { type: String, default: "Number keyboard" },
+    showConfirm: { type: Boolean, default: true },
+    className: { type: String, default: void 0 },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["update:modelValue", "change", "key-press", "delete", "confirm"],
+  setup(props, { attrs, emit }) {
+    const innerValue = _vue.ref.call(void 0, _tigercatcore.normalizeNumberKeyboardValue.call(void 0, props.defaultValue));
+    const isControlled = _vue.computed.call(void 0, () => props.modelValue !== void 0);
+    const currentValue = _vue.computed.call(void 0, 
+      () => isControlled.value ? _tigercatcore.normalizeNumberKeyboardValue.call(void 0, props.modelValue) : innerValue.value
+    );
+    const isDisabled = _vue.computed.call(void 0, () => props.disabled || props.readonly);
+    const keys = _vue.computed.call(void 0, 
+      () => _tigercatcore.getNumberKeyboardKeys.call(void 0, {
+        mode: props.mode,
+        decimalSeparator: props.decimalSeparator,
+        deleteText: props.deleteText,
+        confirmText: props.confirmText,
+        showConfirm: props.showConfirm
+      })
+    );
+    function emitChange(nextValue, payload) {
+      if (!isControlled.value) innerValue.value = nextValue;
+      emit("update:modelValue", nextValue);
+      emit("change", nextValue, payload);
+    }
+    function handleKeyClick(key) {
+      if (isDisabled.value || key.type === "empty") return;
+      const action = _tigercatcore.getNumberKeyboardAction.call(void 0, key);
+      const nextValue = action === "delete" ? _tigercatcore.deleteNumberKeyboardValue.call(void 0, currentValue.value) : action === "input" ? _tigercatcore.applyNumberKeyboardInput.call(void 0, currentValue.value, key.value, {
+        mode: props.mode,
+        maxLength: props.maxLength,
+        precision: props.precision,
+        decimalSeparator: props.decimalSeparator
+      }) : currentValue.value;
+      const payload = {
+        value: nextValue,
+        key: key.value,
+        action,
+        mode: props.mode
+      };
+      emit("key-press", key, payload);
+      if (action === "confirm") {
+        emit("confirm", currentValue.value, { ...payload, value: currentValue.value });
+        return;
+      }
+      if (action === "delete") emit("delete", nextValue, payload);
+      if (nextValue !== currentValue.value) emitChange(nextValue, payload);
+    }
+    const rootClasses = _vue.computed.call(void 0, 
+      () => _tigercatcore.classNames.call(void 0, _tigercatcore.numberKeyboardRootClasses, props.className, _tigercatcore.coerceClassValue.call(void 0, attrs.class))
+    );
+    const rootStyle = _vue.computed.call(void 0, 
+      () => _tigercatcore.mergeStyleValues.call(void 0, props.style, attrs.style)
+    );
+    return () => {
+      const forwardedAttrs = Object.fromEntries(
+        Object.entries(attrs).filter(([key]) => key !== "class" && key !== "style")
+      );
+      return _vue.h.call(void 0, 
+        "div",
+        {
+          ...forwardedAttrs,
+          class: rootClasses.value,
+          style: rootStyle.value,
+          role: "group",
+          "aria-label": props.ariaLabel,
+          "aria-disabled": isDisabled.value || void 0
+        },
+        [
+          _vue.h.call(void 0, 
+            "div",
+            { class: _tigercatcore.numberKeyboardGridClasses },
+            keys.value.map(
+              (key, index) => _vue.h.call(void 0, 
+                "button",
+                {
+                  key: `${key.type}-${key.value}-${index}`,
+                  type: "button",
+                  class: _tigercatcore.getNumberKeyboardKeyClasses.call(void 0, key, isDisabled.value),
+                  disabled: isDisabled.value || key.disabled,
+                  "aria-label": key.ariaLabel,
+                  "data-key": key.value,
+                  onClick: () => handleKeyClick(key)
+                },
+                key.label
+              )
+            )
+          )
+        ]
+      );
+    };
+  }
+});
+var NumberKeyboard_default = NumberKeyboard;
+
+
+
+
+exports.NumberKeyboard = NumberKeyboard; exports.NumberKeyboard_default = NumberKeyboard_default;

package/dist/chunk-5PXTMXXS.js

@@ -1,10 +1,15 @@
-'use strict';
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/components/ChartAxis.ts
+var _vue = require('vue');
 
-var vue = require('vue');
-var tigercatCore = require('@expcat/tigercat-core');
 
-// src/components/ChartAxis.ts
-var ChartAxis = vue.defineComponent({
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var ChartAxis = _vue.defineComponent.call(void 0, {
   name: "TigerChartAxis",
   inheritAttrs: false,
   props: {
@@ -54,14 +59,14 @@ var ChartAxis = vue.defineComponent({
     }
   },
   setup(props, { attrs }) {
-    const ticks = vue.computed(
-      () => tigercatCore.getChartAxisTicks(props.scale, {
+    const ticks = _vue.computed.call(void 0, 
+      () => _tigercatcore.getChartAxisTicks.call(void 0, props.scale, {
         tickCount: props.ticks,
         tickValues: props.tickValues,
         tickFormat: props.tickFormat
       })
     );
-    const axisClasses = vue.computed(() => tigercatCore.classNames(tigercatCore.coerceClassValue(attrs.class), props.className));
+    const axisClasses = _vue.computed.call(void 0, () => _tigercatcore.classNames.call(void 0, _tigercatcore.coerceClassValue.call(void 0, attrs.class), props.className));
     return () => {
       const isHorizontal = props.orientation === "top" || props.orientation === "bottom";
       const isTopOrLeft = props.orientation === "top" || props.orientation === "left";
@@ -71,7 +76,7 @@ var ChartAxis = vue.defineComponent({
       const tickDirection = isTopOrLeft ? -1 : 1;
       const labelBase = props.tickSize + props.tickPadding + props.labelOffset;
       const labelPosition = (rangeStart + rangeEnd) / 2;
-      return vue.h(
+      return _vue.h.call(void 0, 
         "g",
         {
           ...attrs,
@@ -79,9 +84,9 @@ var ChartAxis = vue.defineComponent({
           transform: `translate(${props.x}, ${props.y})`
         },
         [
-          vue.h("line", {
+          _vue.h.call(void 0, "line", {
             ...axisLine,
-            class: tigercatCore.chartAxisLineClasses,
+            class: _tigercatcore.chartAxisLineClasses,
             "data-axis-line": "true"
           }),
           ...ticks.value.map((tick) => {
@@ -107,25 +112,25 @@ var ChartAxis = vue.defineComponent({
               "text-anchor": isTopOrLeft ? "end" : "start",
               dy: "0.32em"
             };
-            return vue.h("g", { "data-axis-tick": "true" }, [
-              vue.h("line", {
+            return _vue.h.call(void 0, "g", { "data-axis-tick": "true" }, [
+              _vue.h.call(void 0, "line", {
                 ...tickLine,
-                class: tigercatCore.chartAxisTickLineClasses
+                class: _tigercatcore.chartAxisTickLineClasses
               }),
-              vue.h(
+              _vue.h.call(void 0, 
                 "text",
                 {
                   ...textProps,
-                  class: tigercatCore.chartAxisTickTextClasses
+                  class: _tigercatcore.chartAxisTickTextClasses
                 },
                 tick.label
               )
             ]);
           }),
-          props.label ? vue.h(
+          props.label ? _vue.h.call(void 0, 
             "text",
             {
-              class: tigercatCore.chartAxisLabelClasses,
+              class: _tigercatcore.chartAxisLabelClasses,
               "data-axis-label": "true",
               ...isHorizontal ? {
                 x: labelPosition,
@@ -148,5 +153,7 @@ var ChartAxis = vue.defineComponent({
 });
 var ChartAxis_default = ChartAxis;
 
-exports.ChartAxis = ChartAxis;
-exports.ChartAxis_default = ChartAxis_default;
+
+
+
+exports.ChartAxis = ChartAxis; exports.ChartAxis_default = ChartAxis_default;

package/dist/chunk-5UOAWXOQ.js

@@ -0,0 +1,243 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/components/CronEditor.ts
+var _vue = require('vue');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _tigercatcore = require('@expcat/tigercat-core');
+var modeOptions = [
+  { label: "Any", value: "any" },
+  { label: "Every", value: "every" },
+  { label: "Specific", value: "specific" },
+  { label: "Range", value: "range" },
+  { label: "Custom", value: "custom" }
+];
+var CronEditor = _vue.defineComponent.call(void 0, {
+  name: "TigerCronEditor",
+  props: {
+    modelValue: { type: String, default: void 0 },
+    defaultValue: { type: String, default: _tigercatcore.defaultCronExpression },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    size: { type: String, default: "md" },
+    presets: { type: Array, default: () => _tigercatcore.defaultCronPresets },
+    ariaLabel: { type: String, default: "Cron editor" }
+  },
+  emits: ["update:modelValue", "change", "validate"],
+  setup(props, { attrs, emit }) {
+    const innerValue = _vue.ref.call(void 0, props.defaultValue);
+    const expression = _vue.computed.call(void 0, () => _nullishCoalesce(props.modelValue, () => ( innerValue.value)));
+    const validation = _vue.computed.call(void 0, () => _tigercatcore.validateCronExpression.call(void 0, expression.value));
+    const inactive = _vue.computed.call(void 0, () => props.disabled || props.readonly);
+    function commit(nextValue) {
+      const normalized = _tigercatcore.normalizeCronExpression.call(void 0, nextValue);
+      const nextValidation = _tigercatcore.validateCronExpression.call(void 0, normalized);
+      if (props.modelValue === void 0) innerValue.value = normalized;
+      emit("update:modelValue", normalized);
+      emit("change", normalized, nextValidation);
+      emit("validate", nextValidation);
+    }
+    function handleRawExpressionChange(nextValue) {
+      const nextValidation = _tigercatcore.validateCronExpression.call(void 0, nextValue);
+      if (props.modelValue === void 0) innerValue.value = nextValue;
+      emit("update:modelValue", nextValue);
+      emit("change", nextValue, nextValidation);
+      emit("validate", nextValidation);
+    }
+    function handleFieldRawChange(meta, raw) {
+      commit(_tigercatcore.updateCronExpressionField.call(void 0, expression.value, meta.key, raw));
+    }
+    function handleModeChange(meta, control, mode) {
+      const nextControl = {
+        ...control,
+        mode,
+        value: _nullishCoalesce(control.value, () => ( meta.min)),
+        start: _nullishCoalesce(control.start, () => ( meta.min)),
+        end: _nullishCoalesce(control.end, () => ( meta.max)),
+        step: _nullishCoalesce(control.step, () => ( 1))
+      };
+      handleFieldRawChange(meta, _tigercatcore.buildCronFieldValue.call(void 0, nextControl, meta));
+    }
+    function renderFieldControl(meta, control) {
+      if (control.mode === "any") return void 0;
+      if (control.mode === "every") {
+        return _vue.h.call(void 0, "input", {
+          type: "number",
+          min: 1,
+          max: meta.max,
+          class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+          value: _nullishCoalesce(control.step, () => ( 1)),
+          disabled: inactive.value,
+          "aria-label": `${meta.label} step`,
+          onInput: (event) => handleFieldRawChange(
+            meta,
+            _tigercatcore.buildCronFieldValue.call(void 0, 
+              { ...control, step: Number(event.target.value) },
+              meta
+            )
+          )
+        });
+      }
+      if (control.mode === "specific") {
+        return _vue.h.call(void 0, "input", {
+          type: "number",
+          min: meta.min,
+          max: meta.max,
+          class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+          value: _nullishCoalesce(control.value, () => ( meta.min)),
+          disabled: inactive.value,
+          "aria-label": `${meta.label} value`,
+          onInput: (event) => handleFieldRawChange(
+            meta,
+            _tigercatcore.buildCronFieldValue.call(void 0, 
+              { ...control, value: Number(event.target.value) },
+              meta
+            )
+          )
+        });
+      }
+      if (control.mode === "range") {
+        return _vue.h.call(void 0, "div", { class: "grid grid-cols-2 gap-1" }, [
+          _vue.h.call(void 0, "input", {
+            type: "number",
+            min: meta.min,
+            max: meta.max,
+            class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+            value: _nullishCoalesce(control.start, () => ( meta.min)),
+            disabled: inactive.value,
+            "aria-label": `${meta.label} range start`,
+            onInput: (event) => handleFieldRawChange(
+              meta,
+              _tigercatcore.buildCronFieldValue.call(void 0, 
+                { ...control, start: Number(event.target.value) },
+                meta
+              )
+            )
+          }),
+          _vue.h.call(void 0, "input", {
+            type: "number",
+            min: meta.min,
+            max: meta.max,
+            class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+            value: _nullishCoalesce(control.end, () => ( meta.max)),
+            disabled: inactive.value,
+            "aria-label": `${meta.label} range end`,
+            onInput: (event) => handleFieldRawChange(
+              meta,
+              _tigercatcore.buildCronFieldValue.call(void 0, 
+                { ...control, end: Number(event.target.value) },
+                meta
+              )
+            )
+          })
+        ]);
+      }
+      return _vue.h.call(void 0, "input", {
+        type: "text",
+        class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+        value: control.raw,
+        disabled: inactive.value,
+        "aria-label": `${meta.label} custom value`,
+        onInput: (event) => handleFieldRawChange(meta, event.target.value)
+      });
+    }
+    return () => _vue.h.call(void 0, 
+      "div",
+      {
+        class: _tigercatcore.classNames.call(void 0, _tigercatcore.cronEditorBaseClasses, _tigercatcore.coerceClassValue.call(void 0, attrs.class)),
+        role: "group",
+        "aria-label": props.ariaLabel
+      },
+      [
+        _vue.h.call(void 0, "div", { class: "flex flex-col gap-2 sm:flex-row" }, [
+          _vue.h.call(void 0, "input", {
+            type: "text",
+            class: _tigercatcore.classNames.call(void 0, 
+              _tigercatcore.getCronEditorControlClasses.call(void 0, props.size, !validation.value.valid),
+              "flex-1"
+            ),
+            value: expression.value,
+            disabled: props.disabled,
+            readonly: props.readonly,
+            "aria-label": "Cron expression",
+            onInput: (event) => handleRawExpressionChange(event.target.value)
+          }),
+          props.presets.length > 0 ? _vue.h.call(void 0, 
+            "select",
+            {
+              class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size),
+              value: props.presets.some((preset) => preset.value === expression.value) ? expression.value : "",
+              disabled: inactive.value,
+              "aria-label": "Cron preset",
+              onChange: (event) => {
+                const nextValue = event.target.value;
+                if (nextValue) commit(nextValue);
+              }
+            },
+            [
+              _vue.h.call(void 0, "option", { value: "" }, "Preset"),
+              ...props.presets.map(
+                (preset) => _vue.h.call(void 0, "option", { key: preset.value, value: preset.value }, preset.label)
+              )
+            ]
+          ) : void 0
+        ]),
+        ...validation.value.issues.filter((issue) => issue.field === "expression").map(
+          (issue) => _vue.h.call(void 0, "div", { key: issue.message, class: _tigercatcore.cronEditorErrorClasses }, issue.message)
+        ),
+        _vue.h.call(void 0, 
+          "div",
+          { class: _tigercatcore.cronEditorFieldsClasses },
+          _tigercatcore.cronFieldMetas.map((meta) => {
+            const raw = _tigercatcore.getCronFieldValue.call(void 0, expression.value, meta.key);
+            const control = _tigercatcore.parseCronFieldControl.call(void 0, raw);
+            const issue = _tigercatcore.getCronFieldIssue.call(void 0, validation.value, meta.key);
+            return _vue.h.call(void 0, "div", { key: meta.key, class: _tigercatcore.cronEditorFieldClasses }, [
+              _vue.h.call(void 0, "label", { class: _tigercatcore.cronEditorLabelClasses }, meta.label),
+              _vue.h.call(void 0, 
+                "select",
+                {
+                  class: _tigercatcore.getCronEditorControlClasses.call(void 0, props.size, !!issue),
+                  value: control.mode,
+                  disabled: inactive.value,
+                  "aria-label": `${meta.label} mode`,
+                  onChange: (event) => handleModeChange(
+                    meta,
+                    control,
+                    event.target.value
+                  )
+                },
+                modeOptions.map(
+                  (mode) => _vue.h.call(void 0, "option", { key: mode.value, value: mode.value }, mode.label)
+                )
+              ),
+              renderFieldControl(meta, control),
+              issue ? _vue.h.call(void 0, "div", { class: _tigercatcore.cronEditorErrorClasses }, issue.message) : void 0
+            ]);
+          })
+        )
+      ]
+    );
+  }
+});
+var CronEditor_default = CronEditor;
+
+
+
+
+exports.CronEditor = CronEditor; exports.CronEditor_default = CronEditor_default;