@resistdesign/voltra 3.0.0-alpha.4 → 3.0.0-alpha.41

package/chunk-I2KLQ2HA.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+export { __export, __reExport };

package/chunk-TJFTWPXQ.js

@@ -0,0 +1,39 @@
+// src/app/utils/easy-layout/computeTracks.ts
+var computeTrackPixels = ({
+  tracks,
+  totalPx,
+  gapPx = 0,
+  paddingPx = 0
+}) => {
+  if (!tracks.length) {
+    return [];
+  }
+  const gapsPx = Math.max(0, tracks.length - 1) * Math.max(0, gapPx);
+  const usablePx = Math.max(0, totalPx - Math.max(0, paddingPx) * 2 - gapsPx);
+  let fixedPx = 0;
+  let frTotal = 0;
+  for (const track of tracks) {
+    if (track.kind === "px") {
+      fixedPx += track.value;
+    } else if (track.kind === "pct") {
+      fixedPx += usablePx * track.value / 100;
+    } else {
+      frTotal += track.value;
+    }
+  }
+  const remainderPx = Math.max(0, usablePx - fixedPx);
+  return tracks.map((track) => {
+    if (track.kind === "px") {
+      return track.value;
+    }
+    if (track.kind === "pct") {
+      return usablePx * track.value / 100;
+    }
+    if (frTotal <= 0) {
+      return 0;
+    }
+    return remainderPx * track.value / frTotal;
+  });
+};
+
+export { computeTrackPixels };

package/chunk-WNFRDIBW.js

@@ -0,0 +1,121 @@
+// src/common/Routing.ts
+var PATH_DELIMITER = "/";
+var getPotentialJSONValue = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    return value;
+  }
+};
+var getPathArray = (path, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriDecodeParts = true) => path.split(delimiter).filter(filterEmptyInput ? (p) => p !== "" : () => true).map(uriDecodeParts ? decodeURIComponent : (x) => x).map(useJson ? getPotentialJSONValue : (p) => p).filter(filterEmptyOutput ? (p) => p ?? false : () => true);
+var getPathString = (parts = [], delimiter = PATH_DELIMITER, filterEmptyInput = false, useJson = true, uriEncodeParts = false) => parts.filter(filterEmptyInput ? (p) => p ?? false : () => true).map(useJson ? (p) => JSON.stringify(p) : (x) => x).map(uriEncodeParts ? encodeURIComponent : (x) => x).join(delimiter);
+var mergeStringPaths = (path1, path2, delimiter = PATH_DELIMITER, filterEmptyOutput = false, filterEmptyInput = true, useJson = true, uriEncodeParts = false) => getPathString(
+  [
+    ...getPathArray(
+      path1,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    ),
+    ...getPathArray(
+      path2,
+      delimiter,
+      filterEmptyOutput,
+      filterEmptyInput,
+      useJson,
+      uriEncodeParts
+    )
+  ],
+  delimiter,
+  filterEmptyInput,
+  useJson,
+  uriEncodeParts
+);
+var splitRoutePathParts = (rawPath) => {
+  let path = rawPath;
+  let hash = "";
+  let search = "";
+  const hashIndex = path.indexOf("#");
+  if (hashIndex >= 0) {
+    hash = path.slice(hashIndex);
+    path = path.slice(0, hashIndex);
+  }
+  const searchIndex = path.indexOf("?");
+  if (searchIndex >= 0) {
+    search = path.slice(searchIndex);
+    path = path.slice(0, searchIndex);
+  }
+  return {
+    path,
+    search,
+    hash
+  };
+};
+var resolveRouteAdapterPath = (currentPath, nextPath) => {
+  const rawNextPath = String(nextPath ?? "").trim();
+  if (rawNextPath === "") {
+    return "/";
+  }
+  const { path: rawCurrentBase } = splitRoutePathParts(
+    String(currentPath ?? "").trim()
+  );
+  const { path: rawRelativePath, search, hash } = splitRoutePathParts(rawNextPath);
+  const isAbsoluteTarget = rawRelativePath.startsWith(PATH_DELIMITER);
+  const currentSegments = getPathArray(
+    rawCurrentBase || PATH_DELIMITER,
+    PATH_DELIMITER,
+    true,
+    true,
+    false,
+    false
+  );
+  const outputSegments = isAbsoluteTarget ? [] : [...currentSegments];
+  const relativeSegments = getPathArray(
+    rawRelativePath,
+    PATH_DELIMITER,
+    true,
+    true,
+    false,
+    false
+  );
+  relativeSegments.forEach((segment) => {
+    if (segment === "." || segment === "") {
+      return;
+    }
+    if (segment === "..") {
+      outputSegments.pop();
+      return;
+    }
+    outputSegments.push(segment);
+  });
+  const resolvedPath = outputSegments.length > 0 ? `/${outputSegments.join(PATH_DELIMITER)}` : PATH_DELIMITER;
+  return `${resolvedPath}${search}${hash}`;
+};
+var getParamsAndTestPath = (path, testPath, exact = false) => {
+  const pathList = getPathArray(path);
+  const testPathList = getPathArray(testPath);
+  if (exact && pathList.length !== testPathList.length) {
+    return false;
+  } else {
+    let params = {};
+    if (pathList.length >= testPathList.length) {
+      for (let i = 0; i < testPathList.length; i++) {
+        const testPathPart = testPathList[i];
+        const pathPart = pathList[i];
+        if (testPathPart.startsWith(":")) {
+          const paramName = testPathPart.slice(1);
+          params[paramName] = pathPart;
+        } else if (pathPart !== testPathPart) {
+          return false;
+        }
+      }
+    } else {
+      return false;
+    }
+    return params;
+  }
+};
+
+export { PATH_DELIMITER, getParamsAndTestPath, getPathArray, getPathString, getPotentialJSONValue, mergeStringPaths, resolveRouteAdapterPath };