nuxt-ui-tools 0.1.0

package/dist/runtime/shared/utils/object.js

@@ -0,0 +1,66 @@
+export function omit(obj, keys) {
+  const result = structuredClone(obj);
+  for (const path of keys) {
+    const parts = path.split(".");
+    if (parts.length === 1) {
+      delete result?.[parts?.[0] ?? ""];
+      continue;
+    }
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i] ?? "";
+      if (current === void 0 || current === null) break;
+      if (Array.isArray(current[part])) {
+        const remainingPath = parts.slice(i + 1).join(".");
+        const remainingParts = remainingPath.split(".");
+        for (const item of current[part]) {
+          if (item && typeof item === "object") {
+            let itemCurrent = item;
+            for (let j = 0; j < remainingParts.length - 1; j++) {
+              if (itemCurrent === void 0 || itemCurrent === null) break;
+              itemCurrent = itemCurrent[remainingParts[j] ?? ""];
+            }
+            if (itemCurrent !== void 0 && itemCurrent !== null) {
+              delete itemCurrent[remainingParts[remainingParts.length - 1] ?? ""];
+            }
+          }
+        }
+        break;
+      } else {
+        current = current[part];
+      }
+    }
+    if (current !== void 0 && current !== null && !Array.isArray(result[parts[0] ?? ""])) {
+      const lastPart = parts[parts.length - 1];
+      delete current[lastPart ?? ""];
+    }
+  }
+  return result;
+}
+export function pick(obj, keys) {
+  const result = {};
+  for (const path of keys) {
+    const parts = path.split(".");
+    let current = obj;
+    let target = result;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i] ?? "";
+      const isLast = i === parts.length - 1;
+      if (current === void 0 || current === null) break;
+      if (isLast) {
+        target[part] = current[part];
+      } else {
+        target[part] = target[part] || {};
+        target = target[part];
+        current = current[part];
+      }
+    }
+  }
+  return result;
+}
+export function getObjectProperty(source, path) {
+  return path.split(".").reduce((current, segment) => {
+    if (!current || typeof current !== "object") return void 0;
+    return current[segment];
+  }, source);
+}

package/dist/runtime/shared/utils/path.d.ts

@@ -0,0 +1,9 @@
+import type { GenericObject } from '../types/utils.js';
+export declare function pathSegments(path: string | readonly string[]): string[];
+export declare function getPathValue(source: unknown, path: string | readonly string[]): unknown;
+export declare function relativePathSegments(parentPath: readonly string[], key?: string): string[];
+export declare function getScopedPathValue(source: GenericObject, key: string, parentPath: readonly string[]): unknown;
+export declare function setPathValue(target: GenericObject, path: string | readonly string[], value: unknown): void;
+export declare function cloneValue(value: unknown): unknown;
+export declare function mergeObjects(target: GenericObject, source: GenericObject): void;
+export declare function isRecord(value: unknown): value is GenericObject;

package/dist/runtime/shared/utils/path.js

@@ -0,0 +1,82 @@
+export function pathSegments(path) {
+  const rawSegments = typeof path === "string" ? path.split(".") : path;
+  return rawSegments.flatMap((segment) => segment.split(".")).filter(Boolean);
+}
+export function getPathValue(source, path) {
+  return pathSegments(path).reduce((current, segment) => {
+    if (!isPathContainer(current)) return void 0;
+    return getContainerValue(current, segment);
+  }, source);
+}
+export function relativePathSegments(parentPath, key = "") {
+  const offset = scopedPathOffset(key);
+  const parentSegments = parentPath.flatMap((segment) => segment.split(".")).filter(Boolean);
+  return [
+    ...parentSegments.filter((_segment, index) => index < parentSegments.length - offset),
+    ...key.split(".").slice(1)
+  ].flatMap((segment) => segment.split(".")).filter(Boolean);
+}
+export function getScopedPathValue(source, key, parentPath) {
+  if (key === "$root") return source;
+  if (key.includes("$parent")) return getPathValue(source, relativePathSegments(parentPath, key));
+  return getPathValue(source, key);
+}
+export function setPathValue(target, path, value) {
+  const segments = pathSegments(path);
+  let current = target;
+  segments.forEach((segment, index) => {
+    if (index === segments.length - 1) {
+      setContainerValue(current, segment, value);
+      return;
+    }
+    const child = getContainerValue(current, segment);
+    if (isPathContainer(child)) {
+      current = child;
+      return;
+    }
+    const next = shouldCreateArray(segments[index + 1]) ? [] : {};
+    setContainerValue(current, segment, next);
+    current = next;
+  });
+}
+export function cloneValue(value) {
+  if (Array.isArray(value)) return value.map((item) => cloneValue(item));
+  if (!isRecord(value)) return value;
+  const output = {};
+  for (const [key, child] of Object.entries(value)) output[key] = cloneValue(child);
+  return output;
+}
+export function mergeObjects(target, source) {
+  for (const [key, value] of Object.entries(source)) {
+    if (isRecord(value) && isRecord(target[key])) {
+      mergeObjects(target[key], value);
+      continue;
+    }
+    target[key] = cloneValue(value);
+  }
+}
+export function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPathContainer(value) {
+  return isRecord(value) || Array.isArray(value);
+}
+function getContainerValue(container, segment) {
+  if (Array.isArray(container)) return container[Number(segment)];
+  return container[segment];
+}
+function setContainerValue(container, segment, value) {
+  if (Array.isArray(container)) {
+    container[Number(segment)] = value;
+    return;
+  }
+  container[segment] = value;
+}
+function shouldCreateArray(segment) {
+  return typeof segment === "string" && /^\d+$/.test(segment);
+}
+function scopedPathOffset(key) {
+  const firstSegment = key.split(".")[0];
+  const offset = firstSegment?.split(":").pop();
+  return offset && Number.isFinite(Number(offset)) ? Number(offset) : 0;
+}

package/dist/runtime/shared/utils/predicate.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Type predicate to filter out null and undefined values from arrays.
+ * @example
+ * const arr = [1, null, 2, undefined, 3]
+ * const filtered = arr.filter(isDefined) // typed as number[]
+ */
+export declare function isDefined<T>(value: T): value is NonNullable<T>;
+/**
+ * Type predicate to check if a value is null.
+ */
+export declare function isNull(value: unknown): value is null;
+/**
+ * Type predicate to check if a value is undefined.
+ */
+export declare function isUndefined(value: unknown): value is undefined;
+/**
+ * Type predicate to check if a value is null or undefined.
+ */
+export declare function isNullish(value: unknown): value is null | undefined;
+/**
+ * Type predicate to check if a value is a string.
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Type predicate to check if a value is a non-empty string.
+ */
+export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Type predicate to check if a value is a number (excluding NaN).
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Type predicate to check if a value is a finite number.
+ */
+export declare function isFiniteNumber(value: unknown): value is number;
+/**
+ * Type predicate to check if a value is an integer.
+ */
+export declare function isInteger(value: unknown): value is number;
+/**
+ * Type predicate to check if a value is a positive number.
+ */
+export declare function isPositiveNumber(value: unknown): value is number;
+/**
+ * Type predicate to check if a value is a non-negative number (>= 0).
+ */
+export declare function isNonNegativeNumber(value: unknown): value is number;
+/**
+ * Type predicate to check if a value is a boolean.
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Type predicate to check if a value is a function.
+ */
+export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
+/**
+ * Type predicate to check if a value is an object (excluding null).
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type predicate to check if a value is a symbol.
+ */
+export declare function isSymbol(value: unknown): value is symbol;
+/**
+ * Type predicate to check if a value is a bigint.
+ */
+export declare function isBigInt(value: unknown): value is bigint;
+/**
+ * Type predicate to check if a value is a Date object.
+ */
+export declare function isDate(value: unknown): value is Date;
+/**
+ * Type predicate to check if a value is a valid Date object.
+ */
+export declare function isValidDate(value: unknown): value is Date;
+/**
+ * Type predicate to check if a value is a RegExp.
+ */
+export declare function isRegExp(value: unknown): value is RegExp;
+/**
+ * Type predicate to check if a value is a Promise.
+ */
+export declare function isPromise<T = unknown>(value: unknown): value is Promise<T>;
+/**
+ * Type predicate to check if a value is an Error.
+ */
+export declare function isError(value: unknown): value is Error;
+/**
+ * Type predicate to check if a value is a plain object (not null, not array, not class instance).
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type predicate to check if a value is an array.
+ */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Type predicate to check if a value is a non-empty array.
+ */
+export declare function isNonEmptyArray<T>(value: T[]): value is [T, ...T[]];
+export declare function isNonEmptyArray(value: unknown): value is [unknown, ...unknown[]];
+/**
+ * Type predicate to check if a value is an array of a specific type.
+ */
+export declare function isArrayOf<T>(value: unknown, predicate: (item: unknown) => item is T): value is T[];
+/**
+ * Type predicate to check if a value is a non-empty plain object.
+ */
+export declare function isNonEmptyObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type predicate to check if a value is a primitive (string, number, boolean, null, undefined, symbol, bigint).
+ */
+export declare function isPrimitive(value: unknown): value is string | number | boolean | null | undefined | symbol | bigint;
+/**
+ * Type predicate to check if a value has a specific property.
+ */
+export declare function hasProperty<K extends PropertyKey>(value: unknown, key: K): value is Record<K, unknown>;
+/**
+ * Type predicate to check if a value has specific properties.
+ */
+export declare function hasProperties<K extends PropertyKey>(value: unknown, keys: K[]): value is Record<K, unknown>;
+/**
+ * Type predicate to check if a value has a property with a specific type.
+ */
+export declare function hasTypedProperty<K extends PropertyKey, T>(value: unknown, key: K, predicate: (prop: unknown) => prop is T): value is Record<K, T>;
+/**
+ * Creates a type predicate that checks if a value equals one of the given values.
+ * @example
+ * const isStatus = isOneOf(['pending', 'active', 'completed'] as const)
+ * if (isStatus(value)) { // value is 'pending' | 'active' | 'completed' }
+ */
+export declare function isOneOf<const T extends readonly unknown[]>(values: T): (value: unknown) => value is T[number];
+/**
+ * Creates a negated type predicate.
+ * @example
+ * const isNotNull = not(isNull)
+ * const values = [1, null, 2].filter(isNotNull) // typed as (number | null)[] -> filters nulls
+ */
+export declare function not<T, S extends T>(predicate: (value: T) => value is S): (value: T) => value is Exclude<T, S>;
+/**
+ * Creates a type predicate that checks if a value matches all predicates.
+ */
+export declare function all<T, S extends T>(...predicates: Array<(value: T) => value is S>): (value: T) => value is S;
+/**
+ * Creates a type predicate that checks if a value matches any of the predicates.
+ */
+export declare function some<T, S extends T>(...predicates: Array<(value: T) => value is S>): (value: T) => value is S;
+/**
+ * Type predicate to check if a value is truthy.
+ * Filters out: false, 0, '', null, undefined, NaN
+ */
+export declare function isTruthy<T>(value: T): value is Exclude<T, false | 0 | '' | null | undefined>;
+/**
+ * Type predicate to check if a value is falsy.
+ */
+export declare function isFalsy(value: unknown): value is false | 0 | '' | null | undefined;
+/**
+ * Type predicate to check if a string matches a pattern.
+ */
+export declare function matchesPattern(pattern: RegExp): (value: unknown) => value is string;
+/**
+ * Type predicate to check if a value is a valid email string.
+ */
+export declare function isEmail(value: unknown): value is string;
+/**
+ * Type predicate to check if a value is a valid URL string.
+ */
+export declare function isURL(value: unknown): value is string;
+/**
+ * Type predicate to check if a value is a valid UUID string.
+ */
+export declare const isUUID: (value: unknown) => value is string;
+/**
+ * Type predicate to check if a value is an instance of a class.
+ */
+export declare function isInstanceOf<T>(constructor: new (...args: any[]) => T): (value: unknown) => value is T;
+/**
+ * Type predicate to check if a value is a Map.
+ */
+export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
+/**
+ * Type predicate to check if a value is a Set.
+ */
+export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
+/**
+ * Type predicate to check if a value is a WeakMap.
+ */
+export declare function isWeakMap<K extends WeakKey = WeakKey, V = unknown>(value: unknown): value is WeakMap<K, V>;
+/**
+ * Type predicate to check if a value is a WeakSet.
+ */
+export declare function isWeakSet<T extends WeakKey = WeakKey>(value: unknown): value is WeakSet<T>;
+/**
+ * Type predicate to check if a value is iterable.
+ */
+export declare function isIterable<T = unknown>(value: unknown): value is Iterable<T>;
+/**
+ * Type predicate to check if a value is an ArrayBuffer.
+ */
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+/**
+ * Type predicate to check if a value is a TypedArray.
+ */
+export declare function isTypedArray(value: unknown): value is Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Asserts that a value satisfies a type predicate, throwing if it doesn't.
+ * @throws {Error} If the value doesn't satisfy the predicate
+ */
+export declare function assertType<T>(value: unknown, predicate: (value: unknown) => value is T, message?: string): asserts value is T;
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * @throws {Error} If the value is null or undefined
+ */
+export declare function assertDefined<T>(value: T, message?: string): asserts value is NonNullable<T>;

package/dist/runtime/shared/utils/predicate.js

@@ -0,0 +1,170 @@
+export function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+export function isNull(value) {
+  return value === null;
+}
+export function isUndefined(value) {
+  return value === void 0;
+}
+export function isNullish(value) {
+  return value === null || value === void 0;
+}
+export function isString(value) {
+  return typeof value === "string";
+}
+export function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+export function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+export function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+export function isInteger(value) {
+  return typeof value === "number" && Number.isInteger(value);
+}
+export function isPositiveNumber(value) {
+  return isNumber(value) && value > 0;
+}
+export function isNonNegativeNumber(value) {
+  return isNumber(value) && value >= 0;
+}
+export function isBoolean(value) {
+  return typeof value === "boolean";
+}
+export function isFunction(value) {
+  return typeof value === "function";
+}
+export function isObject(value) {
+  return value !== null && !Array.isArray(value) && typeof value === "object";
+}
+export function isSymbol(value) {
+  return typeof value === "symbol";
+}
+export function isBigInt(value) {
+  return typeof value === "bigint";
+}
+export function isDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+export function isValidDate(value) {
+  return value instanceof Date && !Number.isNaN(value.getTime());
+}
+export function isRegExp(value) {
+  return value instanceof RegExp;
+}
+export function isPromise(value) {
+  return value instanceof Promise || value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+}
+export function isError(value) {
+  return value instanceof Error;
+}
+export function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+export function isArray(value) {
+  return Array.isArray(value);
+}
+export function isNonEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+export function isArrayOf(value, predicate) {
+  return Array.isArray(value) && value.every(predicate);
+}
+export function isNonEmptyObject(value) {
+  return isPlainObject(value) && Object.keys(value).length > 0;
+}
+export function isPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "symbol" || typeof value === "bigint";
+}
+export function hasProperty(value, key) {
+  return value !== null && typeof value === "object" && key in value;
+}
+export function hasProperties(value, keys) {
+  return value !== null && typeof value === "object" && keys.every((key) => key in value);
+}
+export function hasTypedProperty(value, key, predicate) {
+  return hasProperty(value, key) && predicate(value[key]);
+}
+export function isOneOf(values) {
+  return (value) => values.includes(value);
+}
+export function not(predicate) {
+  return (value) => !predicate(value);
+}
+export function all(...predicates) {
+  return (value) => predicates.every((p) => p(value));
+}
+export function some(...predicates) {
+  return (value) => predicates.some((p) => p(value));
+}
+export function isTruthy(value) {
+  return Boolean(value);
+}
+export function isFalsy(value) {
+  return !value;
+}
+export function matchesPattern(pattern) {
+  return (value) => isString(value) && pattern.test(value);
+}
+export function isEmail(value) {
+  if (!isString(value)) return false;
+  const atIndex = value.indexOf("@");
+  if (atIndex < 1) return false;
+  const domain = value.slice(atIndex + 1);
+  const dotIndex = domain.lastIndexOf(".");
+  return dotIndex > 0 && dotIndex < domain.length - 1 && !value.includes(" ");
+}
+export function isURL(value) {
+  if (!isString(value)) return false;
+  try {
+    const url = new URL(value);
+    void url;
+    return true;
+  } catch {
+    return false;
+  }
+}
+export const isUUID = matchesPattern(
+  /^[\da-f]{8}-[\da-f]{4}-[1-5][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i
+);
+export function isInstanceOf(constructor) {
+  return (value) => value instanceof constructor;
+}
+export function isMap(value) {
+  return value instanceof Map;
+}
+export function isSet(value) {
+  return value instanceof Set;
+}
+export function isWeakMap(value) {
+  return value instanceof WeakMap;
+}
+export function isWeakSet(value) {
+  return value instanceof WeakSet;
+}
+export function isIterable(value) {
+  return value !== null && value !== void 0 && typeof value[Symbol.iterator] === "function";
+}
+export function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer;
+}
+export function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+export function assertType(value, predicate, message = "Type assertion failed") {
+  if (!predicate(value)) {
+    throw new Error(message);
+  }
+}
+export function assertDefined(value, message = "Expected value to be defined") {
+  if (value === null || value === void 0) {
+    throw new Error(message);
+  }
+}

package/dist/runtime/shared/utils/registry.d.ts

@@ -0,0 +1,7 @@
+export declare function createKeyedRegistry<const TItem extends {
+    key: string;
+}>(items: readonly TItem[]): {
+    [TKey in TItem['key']]: Extract<TItem, {
+        key: TKey;
+    }>;
+};

package/dist/runtime/shared/utils/registry.js

@@ -0,0 +1,9 @@
+export function createKeyedRegistry(items) {
+  return items.reduce(
+    (registry, item) => ({
+      ...registry,
+      [item.key]: item
+    }),
+    {}
+  );
+}

package/dist/runtime/shared/utils/render.d.ts

@@ -0,0 +1,6 @@
+import { type VNodeChild } from 'vue';
+import type { LazyTextValue, RenderableType } from '../types/utils.js';
+export type RenderableValue<TArgs extends unknown[] = []> = RenderableType | ((...args: TArgs) => RenderableType);
+export type ResolvableTextValue = LazyTextValue;
+export declare function renderVNode<TArgs extends unknown[]>(value: RenderableValue<TArgs>, ...args: TArgs): VNodeChild;
+export declare function resolveTextValue(value: ResolvableTextValue | null | undefined, fallback?: string): string;

package/dist/runtime/shared/utils/render.js

@@ -0,0 +1,13 @@
+import { createTextVNode } from "vue";
+export function renderVNode(value, ...args) {
+  const resolved = typeof value === "function" ? value(...args) : value;
+  if (typeof resolved === "string" || typeof resolved === "number") {
+    return createTextVNode(String(resolved));
+  }
+  return resolved ?? null;
+}
+export function resolveTextValue(value, fallback = "") {
+  if (typeof value === "function") return String(value());
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  return fallback;
+}

package/dist/runtime/shared/utils/responsive.d.ts

@@ -0,0 +1,17 @@
+import type { InferResponsiveValue, ResponsiveBreakpointContext, ResponsiveTransformKey, ResponsiveTransformResult, ResponsiveTransformer, ResponsiveValueInput } from '../types/responsive.js';
+type ResponsiveTransform = ResponsiveTransformKey | ResponsiveTransformer<unknown>;
+export type ViewportLike = {
+    breakpoint: {
+        value: string;
+    };
+    queries: {
+        value: Record<string, {
+            size: number;
+        }>;
+    };
+};
+export declare function parseResponsiveValue(value: string, breakpointKeys: string[]): Record<string, string | null>;
+export declare function resolveResponsiveValueAtBreakpoint<TValue extends ResponsiveValueInput>(value: TValue, context: ResponsiveBreakpointContext): InferResponsiveValue<TValue> | null;
+export declare function resolveResponsiveValueAtBreakpoint<TTransform extends ResponsiveTransform>(value: string, context: ResponsiveBreakpointContext, transform: TTransform): ResponsiveTransformResult<TTransform> | null;
+export declare function getOrderedBreakpointKeys(viewport: ViewportLike): string[];
+export {};

package/dist/runtime/shared/utils/responsive.js

@@ -0,0 +1,46 @@
+export function parseResponsiveValue(value, breakpointKeys) {
+  const tokens = value.trim().split(/\s+/).filter(Boolean).map((token) => {
+    const separatorIndex = token.indexOf(":");
+    if (separatorIndex === -1) return { breakpoint: breakpointKeys[0] ?? "", value: token };
+    return {
+      breakpoint: token.slice(0, separatorIndex),
+      value: token.slice(separatorIndex + 1)
+    };
+  });
+  return breakpointKeys.reduce((acc, breakpoint, index) => {
+    let resolvedValue = tokens.find((token) => token.breakpoint === breakpoint)?.value ?? null;
+    if (resolvedValue) {
+      acc[breakpoint] = resolvedValue;
+      return acc;
+    }
+    let fallbackIndex = index - 1;
+    while (fallbackIndex >= 0 && resolvedValue === null) {
+      resolvedValue = tokens.find((token) => token.breakpoint === breakpointKeys[fallbackIndex])?.value ?? null;
+      fallbackIndex--;
+    }
+    acc[breakpoint] = resolvedValue;
+    return acc;
+  }, {});
+}
+export function resolveResponsiveValueAtBreakpoint(value, context, transform) {
+  if (typeof value !== "string") return value;
+  const resolvedValue = parseResponsiveValue(value, context.breakpointKeys)[context.breakpoint] ?? null;
+  if (resolvedValue === null) return null;
+  return transformResponsiveValue(resolvedValue, transform);
+}
+export function getOrderedBreakpointKeys(viewport) {
+  return Object.entries(viewport.queries.value).sort(([, leftQuery], [, rightQuery]) => leftQuery.size - rightQuery.size).map(([breakpoint]) => breakpoint);
+}
+function transformResponsiveValue(value, transform) {
+  if (transform === void 0 || transform === "string") return value;
+  if (typeof transform === "function") return transform(value);
+  if (transform === "boolean") return value === "true";
+  if (transform === "integer") return Number.parseInt(value, 10);
+  if (transform === "float") return Number.parseFloat(value);
+  if (transform === "grid-cols") return `grid-template-columns: repeat(${value}, minmax(0, 1fr))`;
+  if (transform === "grid-rows") return `grid-template-rows: repeat(${value}, minmax(0, 1fr))`;
+  if (transform === "col") return `grid-column: span ${value} / span ${value}`;
+  if (transform === "row") return `grid-row: span ${value} / span ${value}`;
+  if (transform === "maxWidth") return `max-width: ${value}`;
+  return `max-height: ${value}`;
+}

package/dist/runtime/spreadsheet/components/SpreadsheetImport.d.vue.ts

@@ -0,0 +1,18 @@
+import type { UiToolsLocale, UiToolsMessages } from '#ui-tools/i18n';
+import type { SpreadsheetComponentApi } from './types.js';
+type __VLS_Props = {
+    spreadsheet: SpreadsheetComponentApi;
+    title?: string;
+    description?: string;
+    onDownloadTemplate?: () => void;
+    closable?: boolean;
+    mode?: 'inline' | 'fullscreen';
+    locale?: UiToolsLocale<UiToolsMessages>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;