alinea 1.7.0 → 2.0.0-preview.0

package/dist/chunks/chunk-AC4U3IMS.js

@@ -0,0 +1,205 @@
+// node_modules/react-stately/dist/private/dnd/useDraggableCollectionState.mjs
+import { useState as $16cpX$useState, useRef as $16cpX$useRef } from "react";
+function $b2d15a2f12e80349$export$29efd034f1d79f81(props) {
+  let { getItems, isDisabled, collection, selectionManager, onDragStart, onDragMove, onDragEnd, preview, getAllowedDropOperations } = props;
+  let [, setDragging] = (0, $16cpX$useState)(false);
+  let draggingKeys = (0, $16cpX$useRef)(/* @__PURE__ */ new Set());
+  let draggedKey = (0, $16cpX$useRef)(null);
+  let getKeys = (key) => {
+    let keys = /* @__PURE__ */ new Set();
+    if (selectionManager.isSelected(key)) for (let currentKey of selectionManager.selectedKeys) {
+      let node = collection.getItem(currentKey);
+      if (node) {
+        let isChild = false;
+        let parentKey = node.parentKey;
+        while (parentKey != null) {
+          if (selectionManager.selectedKeys.has(parentKey)) {
+            isChild = true;
+            break;
+          }
+          let parentNode = collection.getItem(parentKey);
+          parentKey = parentNode ? parentNode.parentKey : null;
+        }
+        if (!isChild) keys.add(currentKey);
+      }
+    }
+    else keys.add(key);
+    return keys;
+  };
+  return {
+    collection,
+    selectionManager,
+    get draggedKey() {
+      return draggedKey.current;
+    },
+    get draggingKeys() {
+      return draggingKeys.current;
+    },
+    isDragging(key) {
+      return draggingKeys.current.has(key);
+    },
+    getKeysForDrag: getKeys,
+    getItems(key) {
+      let keys = getKeys(key);
+      let items = [];
+      for (let key2 of keys) {
+        let value = collection.getItem(key2)?.value;
+        if (value != null) items.push(value);
+      }
+      return getItems(getKeys(key), items);
+    },
+    isDisabled,
+    preview,
+    getAllowedDropOperations,
+    startDrag(key, event) {
+      let keys = getKeys(key);
+      draggingKeys.current = keys;
+      draggedKey.current = key;
+      selectionManager.setFocused(false);
+      setDragging(true);
+      if (typeof onDragStart === "function") onDragStart({
+        ...event,
+        keys
+      });
+    },
+    moveDrag(event) {
+      if (typeof onDragMove === "function") onDragMove({
+        ...event,
+        keys: draggingKeys.current
+      });
+    },
+    endDrag(event) {
+      let { isInternal } = event;
+      if (typeof onDragEnd === "function") onDragEnd({
+        ...event,
+        keys: draggingKeys.current,
+        isInternal
+      });
+      draggingKeys.current = /* @__PURE__ */ new Set();
+      draggedKey.current = null;
+      setDragging(false);
+    }
+  };
+}
+
+// node_modules/react-stately/dist/private/dnd/useDroppableCollectionState.mjs
+import { useState as $5gqtb$useState, useRef as $5gqtb$useRef, useCallback as $5gqtb$useCallback } from "react";
+function $e279703d7ed26e75$export$926850f6ecef79d0(props) {
+  let { acceptedDragTypes = "all", isDisabled, onInsert, onRootDrop, onItemDrop, onReorder, onMove, shouldAcceptItemDrop, collection, selectionManager, onDropEnter, getDropOperation, onDrop } = props;
+  let [target, setTarget] = (0, $5gqtb$useState)(null);
+  let targetRef = (0, $5gqtb$useRef)(null);
+  let getOppositeTarget = (target2) => {
+    if (target2.dropPosition === "before") {
+      let node = collection.getItem(target2.key);
+      return node && node.prevKey != null ? {
+        type: "item",
+        key: node.prevKey,
+        dropPosition: "after"
+      } : null;
+    } else if (target2.dropPosition === "after") {
+      let node = collection.getItem(target2.key);
+      return node && node.nextKey != null ? {
+        type: "item",
+        key: node.nextKey,
+        dropPosition: "before"
+      } : null;
+    }
+    return null;
+  };
+  let defaultGetDropOperation = (0, $5gqtb$useCallback)((e) => {
+    let { target: target2, types, allowedOperations, isInternal, draggingKeys } = e;
+    if (isDisabled || !target2) return "cancel";
+    if (acceptedDragTypes === "all" || acceptedDragTypes.some((type) => types.has(type))) {
+      let isValidInsert = onInsert && target2.type === "item" && !isInternal && (target2.dropPosition === "before" || target2.dropPosition === "after");
+      let isValidReorder = onReorder && target2.type === "item" && isInternal && (target2.dropPosition === "before" || target2.dropPosition === "after") && $e279703d7ed26e75$var$isDraggingWithinParent(collection, target2, draggingKeys);
+      let isItemDropAllowed = target2.type !== "item" || target2.dropPosition !== "on" || !shouldAcceptItemDrop || shouldAcceptItemDrop(target2, types);
+      let isValidMove = onMove && target2.type === "item" && isInternal && isItemDropAllowed;
+      let isValidRootDrop = onRootDrop && target2.type === "root" && !isInternal;
+      let isValidOnItemDrop = onItemDrop && target2.type === "item" && target2.dropPosition === "on" && !(isInternal && target2.key != null && draggingKeys.has(target2.key)) && isItemDropAllowed;
+      if (onDrop || isValidInsert || isValidReorder || isValidMove || isValidRootDrop || isValidOnItemDrop) {
+        if (getDropOperation) return getDropOperation(target2, types, allowedOperations);
+        else return allowedOperations[0];
+      }
+    }
+    return "cancel";
+  }, [
+    isDisabled,
+    collection,
+    acceptedDragTypes,
+    getDropOperation,
+    onInsert,
+    onRootDrop,
+    onItemDrop,
+    shouldAcceptItemDrop,
+    onReorder,
+    onMove,
+    onDrop
+  ]);
+  return {
+    collection,
+    selectionManager,
+    isDisabled,
+    target,
+    setTarget(newTarget) {
+      if (this.isDropTarget(newTarget)) return;
+      let target2 = targetRef.current;
+      if (target2 && typeof props.onDropExit === "function") props.onDropExit({
+        type: "dropexit",
+        x: 0,
+        y: 0,
+        target: target2
+      });
+      if (newTarget && typeof onDropEnter === "function") onDropEnter({
+        type: "dropenter",
+        x: 0,
+        y: 0,
+        target: newTarget
+      });
+      targetRef.current = newTarget ?? null;
+      setTarget(newTarget ?? null);
+    },
+    isDropTarget(dropTarget) {
+      let target2 = targetRef.current;
+      if (!target2 || !dropTarget) return false;
+      if ($e279703d7ed26e75$var$isEqualDropTarget(dropTarget, target2)) return true;
+      if (dropTarget?.type === "item" && target2?.type === "item" && dropTarget.key !== target2.key && dropTarget.dropPosition !== target2.dropPosition && dropTarget.dropPosition !== "on" && target2.dropPosition !== "on") return $e279703d7ed26e75$var$isEqualDropTarget(getOppositeTarget(dropTarget), target2) || $e279703d7ed26e75$var$isEqualDropTarget(dropTarget, getOppositeTarget(target2));
+      return false;
+    },
+    getDropOperation(e) {
+      let { target: target2, isInternal, draggingKeys } = e;
+      if (isInternal && target2.type === "item" && draggingKeys.size > 0) {
+        if (draggingKeys.has(target2.key) && target2.dropPosition === "on") return "cancel";
+        let currentKey = target2.key;
+        while (currentKey != null) {
+          let item = collection.getItem(currentKey);
+          let parentKey = item?.parentKey;
+          if (parentKey != null && draggingKeys.has(parentKey)) return "cancel";
+          currentKey = parentKey ?? null;
+        }
+      }
+      return defaultGetDropOperation(e);
+    }
+  };
+}
+function $e279703d7ed26e75$var$isEqualDropTarget(a, b) {
+  if (!a) return !b;
+  switch (a.type) {
+    case "root":
+      return b?.type === "root";
+    case "item":
+      return b?.type === "item" && b?.key === a.key && b?.dropPosition === a.dropPosition;
+  }
+}
+function $e279703d7ed26e75$var$isDraggingWithinParent(collection, target, draggingKeys) {
+  let targetNode = collection.getItem(target.key);
+  for (let key of draggingKeys) {
+    let node = collection.getItem(key);
+    if (node?.parentKey !== targetNode?.parentKey) return false;
+  }
+  return true;
+}
+
+export {
+  $b2d15a2f12e80349$export$29efd034f1d79f81,
+  $e279703d7ed26e75$export$926850f6ecef79d0
+};

package/dist/chunks/chunk-BYJRQTFR.js

@@ -0,0 +1,57 @@
+// node_modules/cookie-es/dist/index.mjs
+var NullObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+function parse(str, options) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  const obj = new NullObject();
+  const opt = options || {};
+  const dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) {
+      break;
+    }
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (opt?.filter && !opt?.filter(key)) {
+      index = endIdx + 1;
+      continue;
+    }
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34) {
+        val = val.slice(1, -1);
+      }
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function decode(str) {
+  return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+  try {
+    return decode2(str);
+  } catch {
+    return str;
+  }
+}
+
+export {
+  parse
+};

package/dist/chunks/chunk-CQ52GEHY.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunks/chunk-EQ3TDHYD.js

@@ -0,0 +1,79 @@
+// package.json with { type: 'json' }
+var package_default = {
+  name: "alinea",
+  version: "2.0.0-preview.0",
+  description: "Headless git-based CMS",
+  repository: "github:alineacms/alinea",
+  license: "MIT",
+  sideEffects: false,
+  type: "module",
+  imports: {
+    "#/*": {
+      "alinea-src": "./src/*",
+      default: "./dist/*"
+    },
+    "#test/*": "./test/*"
+  },
+  exports: {
+    "./package.json": "./package.json",
+    ".": "./dist/index.js",
+    "./css": "./dist/index.css",
+    "./next": {
+      "edge-light": "./dist/next.edge.js",
+      require: "./dist/next.cjs",
+      default: "./dist/next.js"
+    },
+    "./*.cjs": "./dist/*.cjs",
+    "./*": "./dist/*.js",
+    "./core/media/CreatePreview": {
+      "edge-light": "./dist/core/media/CreatePreview.js",
+      worker: "./dist/core/media/CreatePreview.js",
+      browser: "./dist/core/media/CreatePreview.browser.js",
+      default: "./dist/core/media/CreatePreview.js"
+    }
+  },
+  typesVersions: {
+    "*": {
+      "*": [
+        "./dist/*"
+      ]
+    }
+  },
+  bin: "./dist/cli.js",
+  files: [
+    "dist",
+    "llms-full.txt"
+  ],
+  scripts: {
+    build: "tsc -p tsconfig.build.json && bun build.ts",
+    bump: "bun bump.js",
+    cycles: "bun run build && bunx --bun madge --warning --circular dist/index.js",
+    dev: "run-p dev:run",
+    "dev:check": "tsc -w",
+    "dev:run": "bun build.ts --watch -- node dev.js --dir apps/dev -- bun run --cwd apps/dev dev",
+    format: "oxfmt --write src",
+    "format:check": "oxfmt --check src",
+    lint: "oxlint",
+    prepublishOnly: "bun run build",
+    "self-hosted": "bun test/self-hosted/server.ts",
+    stories: "bunx --bun ladle serve",
+    tag: "bun tag.js",
+    spec: "playwright test -c .playwright/playwright.config.ts",
+    trace: "tsc --diagnostics --generateTrace private/trace && analyze-trace private/trace & speedscope private/trace/trace.json",
+    type: "tsc --diagnostics",
+    web: "run-p dev:check web:run",
+    "web:run": "bun build.ts --watch -- node dev.js -- bun run --cwd apps/web dev"
+  },
+  dependencies: {
+    "@alinea/iso": "^0.3.3",
+    esbuild: "^0.28.0"
+  },
+  peerDependencies: {
+    react: "*",
+    "react-dom": "*"
+  }
+};
+
+export {
+  package_default
+};