astro-md-editor 0.0.1

package/.output/server/_libs/zustand.mjs

@@ -0,0 +1,43 @@
+import { a as React } from "./react.mjs";
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+const identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = React.useSyncExternalStore(
+    api.subscribe,
+    React.useCallback(() => selector(api.getState()), [api, selector]),
+    React.useCallback(() => selector(api.getInitialState()), [api, selector])
+  );
+  React.useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = ((createState) => createState ? createImpl(createState) : createImpl);
+export {
+  create as c
+};

package/.output/server/_ssr/RightSidebar-RSY9M7XF.mjs

@@ -0,0 +1,218 @@
+import { c as createServerRpc } from "./createServerRpc-29xaFZcb.mjs";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, resolve, relative, join, extname } from "node:path";
+import { getCollectionsRootPath } from "./collections.server-D6U2tEsT.mjs";
+import { c as createServerFn } from "./index.mjs";
+import "../_libs/tanstack__history.mjs";
+import "../_libs/tanstack__router-core.mjs";
+import "../_libs/cookie-es.mjs";
+import "../_libs/tiny-invariant.mjs";
+import "../_libs/seroval.mjs";
+import "../_libs/seroval-plugins.mjs";
+import "node:stream/web";
+import "node:stream";
+import "node:async_hooks";
+import "../_libs/h3-v2.mjs";
+import "../_libs/rou3.mjs";
+import "../_libs/srvx.mjs";
+import "node:http";
+import "node:https";
+import "node:http2";
+import "../_libs/react.mjs";
+import "../_libs/tanstack__react-router.mjs";
+import "../_libs/react-dom.mjs";
+import "util";
+import "crypto";
+import "async_hooks";
+import "stream";
+import "../_libs/isbot.mjs";
+import "../_libs/tiny-warning.mjs";
+const IMAGE_MIME_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml"
+};
+let cachedRootDir;
+let cachedAssets;
+let cachedAssetsById;
+function toPosix(pathLike) {
+  return pathLike.replaceAll("\\", "/");
+}
+function toRelativePath(fromPath, toPath) {
+  const rawRelative = toPosix(relative(fromPath, toPath));
+  if (rawRelative.length === 0) {
+    return "./";
+  }
+  return rawRelative.startsWith(".") ? rawRelative : `./${rawRelative}`;
+}
+function getMimeType(fileName) {
+  const extension = extname(fileName).toLowerCase();
+  return IMAGE_MIME_TYPES[extension];
+}
+async function collectImageAssetsForSource(params) {
+  const sourceRoot = resolve(params.rootDir, params.source);
+  async function walkDirectory(dirPath) {
+    let entries;
+    try {
+      entries = await readdir(dirPath, {
+        withFileTypes: true
+      });
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      throw error;
+    }
+    const assets = [];
+    for (const entry of entries) {
+      const absolutePath = join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        assets.push(...await walkDirectory(absolutePath));
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const mimeType = getMimeType(entry.name);
+      if (!mimeType) {
+        continue;
+      }
+      const sourceRelativePath = toPosix(relative(sourceRoot, absolutePath));
+      assets.push({
+        id: `${params.source}:${sourceRelativePath}`,
+        source: params.source,
+        absolutePath,
+        sourceRelativePath,
+        mimeType
+      });
+    }
+    return assets;
+  }
+  return walkDirectory(sourceRoot);
+}
+async function buildImageAssetIndex(rootDir) {
+  const [srcAssets, publicAssets] = await Promise.all([
+    collectImageAssetsForSource({
+      rootDir,
+      source: "src"
+    }),
+    collectImageAssetsForSource({
+      rootDir,
+      source: "public"
+    })
+  ]);
+  return [...srcAssets, ...publicAssets].sort((a, b) => {
+    if (a.source !== b.source) {
+      return a.source.localeCompare(b.source);
+    }
+    return a.sourceRelativePath.localeCompare(b.sourceRelativePath);
+  });
+}
+async function getImageIndex() {
+  const rootDir = getCollectionsRootPath();
+  if (cachedRootDir === rootDir && cachedAssets && cachedAssetsById) {
+    return cachedAssets;
+  }
+  const assets = await buildImageAssetIndex(rootDir);
+  cachedRootDir = rootDir;
+  cachedAssets = assets;
+  cachedAssetsById = new Map(assets.map((asset) => [asset.id, asset]));
+  return assets;
+}
+async function listImageAssetsForFile(currentFilePath, sourceMode = "asset") {
+  const targetSource = sourceMode === "public" ? "public" : "src";
+  const assets = (await getImageIndex()).filter((asset) => {
+    return asset.source === targetSource;
+  });
+  const fileDirectory = dirname(resolve(currentFilePath));
+  return assets.map((asset) => {
+    const value = asset.source === "public" ? `/${asset.sourceRelativePath}` : toRelativePath(fileDirectory, asset.absolutePath);
+    return {
+      id: asset.id,
+      source: asset.source,
+      displayPath: asset.sourceRelativePath,
+      value
+    };
+  });
+}
+async function readImageAssetPreviewById(assetId) {
+  await getImageIndex();
+  const asset = cachedAssetsById?.get(assetId);
+  if (!asset) {
+    throw new Error(`Image asset not found: ${assetId}`);
+  }
+  const bytes = await readFile(asset.absolutePath);
+  return {
+    bytes,
+    mimeType: asset.mimeType
+  };
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const listImageAssets_createServerFn_handler = createServerRpc({
+  id: "c39d1a9dd4bf0ef421bf4f2daf36aab12030ba358e594364ba10b3659b27b480",
+  name: "listImageAssets",
+  filename: "src/components/editor/RightSidebar.tsx"
+}, (opts) => listImageAssets.__executeServer(opts));
+const listImageAssets = createServerFn({
+  method: "POST"
+}).inputValidator((payload) => {
+  if (!isObjectRecord(payload)) {
+    throw new Error("Invalid asset list payload.");
+  }
+  const currentFilePath = payload.currentFilePath;
+  if (typeof currentFilePath !== "string" || currentFilePath.length === 0) {
+    throw new Error("Missing current file path.");
+  }
+  const sourceMode = payload.sourceMode;
+  if (sourceMode !== "asset" && sourceMode !== "public") {
+    throw new Error("Invalid image source mode.");
+  }
+  return {
+    currentFilePath,
+    sourceMode
+  };
+}).handler(listImageAssets_createServerFn_handler, async ({
+  data
+}) => {
+  return listImageAssetsForFile(data.currentFilePath, data.sourceMode);
+});
+const getImageAssetPreview_createServerFn_handler = createServerRpc({
+  id: "91a56e4138efcf4efad5b435140f056a882a5f54203e1c4d3b0f274ea2f876f5",
+  name: "getImageAssetPreview",
+  filename: "src/components/editor/RightSidebar.tsx"
+}, (opts) => getImageAssetPreview.__executeServer(opts));
+const getImageAssetPreview = createServerFn({
+  method: "POST"
+}).inputValidator((payload) => {
+  if (!isObjectRecord(payload)) {
+    throw new Error("Invalid asset preview payload.");
+  }
+  const assetId = payload.assetId;
+  if (typeof assetId !== "string" || assetId.length === 0) {
+    throw new Error("Missing asset id.");
+  }
+  return {
+    assetId
+  };
+}).handler(getImageAssetPreview_createServerFn_handler, async ({
+  data
+}) => {
+  const preview = await readImageAssetPreviewById(data.assetId);
+  const bodyBytes = new Uint8Array(preview.bytes);
+  return new Response(bodyBytes, {
+    headers: {
+      "Content-Type": preview.mimeType,
+      "Cache-Control": "public, max-age=300"
+    }
+  });
+});
+export {
+  getImageAssetPreview_createServerFn_handler,
+  listImageAssets_createServerFn_handler
+};

package/.output/server/_ssr/collections.server-D6U2tEsT.mjs

@@ -0,0 +1,120 @@
+const COLLECTIONS_JSON_B64_ENV_KEY = "APP_COLLECTIONS_JSON_B64";
+const COLLECTIONS_ROOT_ENV_KEY = "APP_COLLECTIONS_ROOT";
+let cachedCollectionsRaw;
+let cachedCollectionsData;
+let hasParsedCollectionsData = false;
+function requireEnvValue(key) {
+  const value = process.env[key];
+  if (!value) {
+    throw new Error(
+      `[collections] Missing ${key}. Start the app with the bootstrap launcher.`
+    );
+  }
+  return value;
+}
+function getCollectionsRaw() {
+  if (cachedCollectionsRaw !== void 0) {
+    return cachedCollectionsRaw;
+  }
+  const encoded = requireEnvValue(COLLECTIONS_JSON_B64_ENV_KEY);
+  cachedCollectionsRaw = Buffer.from(encoded, "base64").toString("utf8");
+  return cachedCollectionsRaw;
+}
+function asObjectRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function asFieldUiMap(value) {
+  const record = asObjectRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const parsed = {};
+  for (const [key, rawValue] of Object.entries(record)) {
+    if (rawValue === "image" || rawValue === "imageArray" || rawValue === "color") {
+      if (rawValue === "color") {
+        parsed[key] = { kind: "color" };
+        continue;
+      }
+      parsed[key] = {
+        kind: rawValue,
+        mode: "asset"
+      };
+      continue;
+    }
+    const rawConfig = asObjectRecord(rawValue);
+    if (!rawConfig || typeof rawConfig.kind !== "string") {
+      continue;
+    }
+    if (rawConfig.kind === "image" || rawConfig.kind === "imageArray") {
+      parsed[key] = {
+        kind: rawConfig.kind,
+        mode: rawConfig.mode === "public" ? "public" : "asset"
+      };
+      continue;
+    }
+    if (rawConfig.kind === "color") {
+      parsed[key] = {
+        kind: "color"
+      };
+    }
+  }
+  return Object.keys(parsed).length > 0 ? parsed : void 0;
+}
+function cloneObjectRecord(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getParsedCollectionsData() {
+  if (hasParsedCollectionsData) {
+    return cachedCollectionsData;
+  }
+  const raw = getCollectionsRaw();
+  cachedCollectionsData = JSON.parse(raw);
+  hasParsedCollectionsData = true;
+  return cachedCollectionsData;
+}
+function getCollectionsData() {
+  const data = getParsedCollectionsData();
+  return data.collections.map((collection) => ({
+    name: collection.name,
+    hasSchema: collection.hasSchema,
+    schema: asObjectRecord(collection.schema),
+    fieldUi: asFieldUiMap(collection.fieldUi),
+    files: (collection.files ?? []).map((file) => ({
+      ...file,
+      data: cloneObjectRecord(asObjectRecord(file.data) ?? {})
+    }))
+  }));
+}
+function updateCollectionsFileCache(params) {
+  const parsed = getParsedCollectionsData();
+  const targetCollection = parsed.collections.find(
+    (collection) => collection.name === params.collectionName
+  );
+  if (!targetCollection?.files) {
+    return false;
+  }
+  const targetFile = targetCollection.files.find(
+    (file) => file.id === params.fileId
+  );
+  if (!targetFile) {
+    return false;
+  }
+  targetFile.data = cloneObjectRecord(params.data);
+  targetFile.content = params.content;
+  cachedCollectionsRaw = JSON.stringify(parsed);
+  cachedCollectionsData = parsed;
+  hasParsedCollectionsData = true;
+  return true;
+}
+function getCollectionsRootPath() {
+  return requireEnvValue(COLLECTIONS_ROOT_ENV_KEY);
+}
+export {
+  getCollectionsData,
+  getCollectionsRaw,
+  getCollectionsRootPath,
+  updateCollectionsFileCache
+};

package/.output/server/_ssr/createServerRpc-29xaFZcb.mjs

@@ -0,0 +1,12 @@
+import { T as TSS_SERVER_FUNCTION } from "./index.mjs";
+const createServerRpc = (serverFnMeta, splitImportFn) => {
+  const url = "/_serverFn/" + serverFnMeta.id;
+  return Object.assign(splitImportFn, {
+    url,
+    serverFnMeta,
+    [TSS_SERVER_FUNCTION]: true
+  });
+};
+export {
+  createServerRpc as c
+};