@fuma-content/studio 0.1.0 → 1.0.1

package/build/server/assets/config-Cb909uq6.js

@@ -0,0 +1,257 @@
+import { defineCollectionHook } from "fuma-content/collections";
+import { MDXCollection } from "fuma-content/collections/mdx";
+import { j as jsxRuntime_reactServerExports } from "./jsx-runtime.react-server-D3We4JeM.js";
+import fs from "node:fs/promises";
+import minpath from "node:path";
+import grayMatter from "gray-matter";
+import { getJSONSchema, Core } from "fuma-content";
+import { DataCollection } from "fuma-content/collections/data";
+import { load, dump } from "js-yaml";
+import { createDynamicCore } from "fuma-content/dynamic";
+function fileDocument(collection, fullPath, name) {
+  const relativePath = minpath.relative(collection.dir, fullPath);
+  return {
+    id: encodeId(relativePath),
+    isFile: true,
+    filePath: fullPath,
+    name: name ?? relativePath,
+    toItem({ collectionId }) {
+      return {
+        id: this.id,
+        name: this.name,
+        permissions: {
+          delete: collection.pluginHook(studioHook).actions?.deleteDocument !== void 0
+        },
+        collectionId
+      };
+    },
+    async read() {
+      try {
+        return (await fs.readFile(this.filePath)).toString();
+      } catch {
+        return;
+      }
+    },
+    async write(content) {
+      await fs.writeFile(this.filePath, content);
+    }
+  };
+}
+function encodeId(file) {
+  return file.replaceAll("/", "--");
+}
+async function createFileDocument(collection, name, content) {
+  const filePath = minpath.join(collection.dir, name);
+  if (!collection.hasFile(filePath)) {
+    throw new Error(`invalid collection name: ${name}`);
+  }
+  const exists = await fs.access(filePath, fs.constants.R_OK).then(() => true).catch(() => false);
+  if (exists) {
+    throw new Error(`document ${name} already exists`);
+  }
+  await fs.mkdir(minpath.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  const relativePath = minpath.relative(collection.dir, filePath);
+  return {
+    id: encodeId(relativePath),
+    fullPath: filePath,
+    relativePath
+  };
+}
+function isMDXDocument(doc) {
+  return "isMDX" in doc && doc.isMDX === true;
+}
+function mdxDocument(collection, file, name) {
+  return {
+    isMDX: true,
+    ...fileDocument(collection, file, name)
+  };
+}
+function mdxHook(collection) {
+  return {
+    async getDocuments() {
+      collection.invalidateCache();
+      const files = await collection.getFiles();
+      return files.map((file) => {
+        return mdxDocument(collection, minpath.join(collection.dir, file));
+      });
+    },
+    async getDocument(id) {
+      const docs = await this.getDocuments();
+      return docs.find((doc) => doc.id === id);
+    },
+    pages: {
+      async edit({ document }) {
+        const { MDXDocUpdateEditor } = await import("./client-DLzFPnCR.js");
+        const parsed = grayMatter(await document.read() ?? "");
+        const jsonSchema = collection.frontmatterSchema ? JSON.parse(JSON.stringify(getJSONSchema(collection.frontmatterSchema))) : void 0;
+        return /* @__PURE__ */ jsxRuntime_reactServerExports.jsx(
+          MDXDocUpdateEditor,
+          {
+            documentId: document.id,
+            collectionId: collection.name,
+            jsonSchema,
+            frontmatter: parsed.data,
+            content: parsed.content
+          },
+          document.id
+        );
+      }
+    },
+    toItem() {
+      return { id: collection.name, name: collection.name, supportStudio: true, badge: "MDX" };
+    },
+    async client() {
+      const { clientContext } = await import("./client-DLzFPnCR.js");
+      return clientContext;
+    },
+    actions: {
+      async deleteDocument(options) {
+        try {
+          await fs.rm(options.document.filePath);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function isDataDocument(doc) {
+  return "isData" in doc && doc.isData === true;
+}
+const encoderDecoders = {
+  json: {
+    encode(data) {
+      return JSON.stringify(data, null, 2);
+    },
+    decode(content) {
+      return JSON.parse(content);
+    }
+  },
+  yaml: {
+    encode(data) {
+      return dump(data);
+    },
+    decode(content) {
+      return load(content);
+    }
+  }
+};
+function getEncoderDecoder(format) {
+  return encoderDecoders[format] ?? encoderDecoders.json;
+}
+function dataDocument(collection, file, name) {
+  return {
+    isData: true,
+    ...getEncoderDecoder(minpath.extname(file).slice(1)),
+    ...fileDocument(collection, file, name)
+  };
+}
+function dataHook(collection) {
+  return {
+    async getDocuments() {
+      collection.invalidateCache();
+      const files = await collection.getFiles();
+      return files.map((file) => {
+        return dataDocument(collection, minpath.join(collection.dir, file));
+      });
+    },
+    async getDocument(id) {
+      const docs = await this.getDocuments();
+      return docs.find((doc) => doc.id === id);
+    },
+    toItem() {
+      return {
+        id: collection.name,
+        name: collection.name,
+        supportStudio: true,
+        badge: "Data",
+        _data: {
+          formats: collection.supportedFileFormats ?? ["json", "yaml"]
+        }
+      };
+    },
+    pages: {
+      async edit({ document }) {
+        const { DataDocEdit } = await import("./client-BdxXy6rH.js");
+        const content = await document.read() ?? "";
+        const jsonSchema = collection.schema ? JSON.parse(JSON.stringify(getJSONSchema(collection.schema))) : void 0;
+        return /* @__PURE__ */ jsxRuntime_reactServerExports.jsx(
+          DataDocEdit,
+          {
+            documentId: document.id,
+            collectionId: collection.name,
+            jsonSchema,
+            data: await document.decode(content)
+          },
+          document.id
+        );
+      }
+    },
+    async client() {
+      const { clientContext } = await import("./client-BdxXy6rH.js");
+      return clientContext;
+    },
+    actions: {
+      async deleteDocument(options) {
+        try {
+          await fs.rm(options.document.filePath);
+        } catch {
+        }
+      }
+    }
+  };
+}
+const studioHook = defineCollectionHook(
+  (collection, options) => {
+    if (options) return options;
+    if (collection instanceof MDXCollection) return mdxHook(collection);
+    if (collection instanceof DataCollection) return dataHook(collection);
+    return {
+      disabled: true,
+      getDocuments() {
+        return [];
+      },
+      getDocument() {
+        return void 0;
+      },
+      toItem() {
+        return {
+          id: collection.name,
+          name: collection.name,
+          supportStudio: false,
+          badge: collection.constructor.name
+        };
+      }
+    };
+  }
+);
+const dynamic = createDynamicCore({
+  core: new Core({
+    outDir: process.env.STUDIO_DIST,
+    configPath: process.env.STUDIO_CONFIG,
+    cwd: process.env.STUDIO_PARENT_DIR
+  }),
+  mode: "production",
+  compileMode: true
+});
+async function getCore() {
+  return dynamic.getCore();
+}
+async function requireDocument(collectionId, documentId) {
+  const core = await getCore();
+  const collection = core.getCollection(collectionId);
+  if (!collection) throw new Error(`Missing Collection ${collectionId}`);
+  const document = await collection.pluginHook(studioHook).getDocument(documentId);
+  if (!document) throw new Error(`Missing Document ${documentId}`);
+  return { collection, document };
+}
+export {
+  getEncoderDecoder as a,
+  isDataDocument as b,
+  createFileDocument as c,
+  encoderDecoders as e,
+  getCore as g,
+  isMDXDocument as i,
+  requireDocument as r,
+  studioHook as s
+};

package/build/server/assets/index-X49ifkk3.js

@@ -0,0 +1,9 @@
+import { r as registerClientReference } from "../index.js";
+import "node:async_hooks";
+import "../__vite_rsc_assets_manifest.js";
+const index = /* @__PURE__ */ registerClientReference(() => {
+  throw new Error("Unexpectedly client reference export 'default' is called on server");
+}, "13fa49d3f75d", "default");
+export {
+  index as default
+};

package/build/server/assets/jsx-runtime.react-server-D3We4JeM.js

@@ -0,0 +1,324 @@
+import { a as requireReact_reactServer } from "../index.js";
+var jsxRuntime_reactServer = { exports: {} };
+var reactJsxRuntime_reactServer_production = {};
+var hasRequiredReactJsxRuntime_reactServer_production;
+function requireReactJsxRuntime_reactServer_production() {
+  if (hasRequiredReactJsxRuntime_reactServer_production) return reactJsxRuntime_reactServer_production;
+  hasRequiredReactJsxRuntime_reactServer_production = 1;
+  var React = requireReact_reactServer(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+  if (!React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE)
+    throw Error(
+      'The "react" package in this environment is not configured correctly. The "react-server" condition must be enabled in any environment that runs React Server Components.'
+    );
+  function jsxProd(type, config, maybeKey) {
+    var key = null;
+    void 0 !== maybeKey && (key = "" + maybeKey);
+    void 0 !== config.key && (key = "" + config.key);
+    if ("key" in config) {
+      maybeKey = {};
+      for (var propName in config)
+        "key" !== propName && (maybeKey[propName] = config[propName]);
+    } else maybeKey = config;
+    config = maybeKey.ref;
+    return {
+      $$typeof: REACT_ELEMENT_TYPE,
+      type,
+      key,
+      ref: void 0 !== config ? config : null,
+      props: maybeKey
+    };
+  }
+  reactJsxRuntime_reactServer_production.Fragment = REACT_FRAGMENT_TYPE;
+  reactJsxRuntime_reactServer_production.jsx = jsxProd;
+  reactJsxRuntime_reactServer_production.jsxDEV = void 0;
+  reactJsxRuntime_reactServer_production.jsxs = jsxProd;
+  return reactJsxRuntime_reactServer_production;
+}
+var reactJsxRuntime_reactServer_development = {};
+var hasRequiredReactJsxRuntime_reactServer_development;
+function requireReactJsxRuntime_reactServer_development() {
+  if (hasRequiredReactJsxRuntime_reactServer_development) return reactJsxRuntime_reactServer_development;
+  hasRequiredReactJsxRuntime_reactServer_development = 1;
+  "production" !== process.env.NODE_ENV && (function() {
+    function getComponentNameFromType(type) {
+      if (null == type) return null;
+      if ("function" === typeof type)
+        return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
+      if ("string" === typeof type) return type;
+      switch (type) {
+        case REACT_FRAGMENT_TYPE:
+          return "Fragment";
+        case REACT_PROFILER_TYPE:
+          return "Profiler";
+        case REACT_STRICT_MODE_TYPE:
+          return "StrictMode";
+        case REACT_SUSPENSE_TYPE:
+          return "Suspense";
+        case REACT_SUSPENSE_LIST_TYPE:
+          return "SuspenseList";
+        case REACT_ACTIVITY_TYPE:
+          return "Activity";
+      }
+      if ("object" === typeof type)
+        switch ("number" === typeof type.tag && console.error(
+          "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+        ), type.$$typeof) {
+          case REACT_PORTAL_TYPE:
+            return "Portal";
+          case REACT_CONTEXT_TYPE:
+            return type.displayName || "Context";
+          case REACT_CONSUMER_TYPE:
+            return (type._context.displayName || "Context") + ".Consumer";
+          case REACT_FORWARD_REF_TYPE:
+            var innerType = type.render;
+            type = type.displayName;
+            type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
+            return type;
+          case REACT_MEMO_TYPE:
+            return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
+          case REACT_LAZY_TYPE:
+            innerType = type._payload;
+            type = type._init;
+            try {
+              return getComponentNameFromType(type(innerType));
+            } catch (x) {
+            }
+        }
+      return null;
+    }
+    function testStringCoercion(value) {
+      return "" + value;
+    }
+    function checkKeyStringCoercion(value) {
+      try {
+        testStringCoercion(value);
+        var JSCompiler_inline_result = false;
+      } catch (e) {
+        JSCompiler_inline_result = true;
+      }
+      if (JSCompiler_inline_result) {
+        JSCompiler_inline_result = console;
+        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+        var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
+        JSCompiler_temp_const.call(
+          JSCompiler_inline_result,
+          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+          JSCompiler_inline_result$jscomp$0
+        );
+        return testStringCoercion(value);
+      }
+    }
+    function getTaskName(type) {
+      if (type === REACT_FRAGMENT_TYPE) return "<>";
+      if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
+        return "<...>";
+      try {
+        var name = getComponentNameFromType(type);
+        return name ? "<" + name + ">" : "<...>";
+      } catch (x) {
+        return "<...>";
+      }
+    }
+    function getOwner() {
+      var dispatcher = ReactSharedInternalsServer.A;
+      return null === dispatcher ? null : dispatcher.getOwner();
+    }
+    function UnknownOwner() {
+      return Error("react-stack-top-frame");
+    }
+    function hasValidKey(config) {
+      if (hasOwnProperty.call(config, "key")) {
+        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+        if (getter && getter.isReactWarning) return false;
+      }
+      return void 0 !== config.key;
+    }
+    function defineKeyPropWarningGetter(props, displayName) {
+      function warnAboutAccessingKey() {
+        specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
+          "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+          displayName
+        ));
+      }
+      warnAboutAccessingKey.isReactWarning = true;
+      Object.defineProperty(props, "key", {
+        get: warnAboutAccessingKey,
+        configurable: true
+      });
+    }
+    function elementRefGetterWithDeprecationWarning() {
+      var componentName = getComponentNameFromType(this.type);
+      didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
+        "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+      ));
+      componentName = this.props.ref;
+      return void 0 !== componentName ? componentName : null;
+    }
+    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+      var refProp = props.ref;
+      type = {
+        $$typeof: REACT_ELEMENT_TYPE,
+        type,
+        key,
+        props,
+        _owner: owner
+      };
+      null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
+        enumerable: false,
+        get: elementRefGetterWithDeprecationWarning
+      }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+      type._store = {};
+      Object.defineProperty(type._store, "validated", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: 0
+      });
+      Object.defineProperty(type, "_debugInfo", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: null
+      });
+      Object.defineProperty(type, "_debugStack", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugStack
+      });
+      Object.defineProperty(type, "_debugTask", {
+        configurable: false,
+        enumerable: false,
+        writable: true,
+        value: debugTask
+      });
+      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+      return type;
+    }
+    function jsxDEVImpl(type, config, maybeKey, isStaticChildren, debugStack, debugTask) {
+      var children = config.children;
+      if (void 0 !== children)
+        if (isStaticChildren)
+          if (isArrayImpl(children)) {
+            for (isStaticChildren = 0; isStaticChildren < children.length; isStaticChildren++)
+              validateChildKeys(children[isStaticChildren]);
+            Object.freeze && Object.freeze(children);
+          } else
+            console.error(
+              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+            );
+        else validateChildKeys(children);
+      if (hasOwnProperty.call(config, "key")) {
+        children = getComponentNameFromType(type);
+        var keys = Object.keys(config).filter(function(k) {
+          return "key" !== k;
+        });
+        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(
+          'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+          isStaticChildren,
+          children,
+          keys,
+          children
+        ), didWarnAboutKeySpread[children + isStaticChildren] = true);
+      }
+      children = null;
+      void 0 !== maybeKey && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
+      hasValidKey(config) && (checkKeyStringCoercion(config.key), children = "" + config.key);
+      if ("key" in config) {
+        maybeKey = {};
+        for (var propName in config)
+          "key" !== propName && (maybeKey[propName] = config[propName]);
+      } else maybeKey = config;
+      children && defineKeyPropWarningGetter(
+        maybeKey,
+        "function" === typeof type ? type.displayName || type.name || "Unknown" : type
+      );
+      return ReactElement(
+        type,
+        children,
+        maybeKey,
+        getOwner(),
+        debugStack,
+        debugTask
+      );
+    }
+    function validateChildKeys(node) {
+      isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
+    }
+    function isValidElement(object) {
+      return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    var React = requireReact_reactServer(), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternalsServer = React.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+    if (!ReactSharedInternalsServer)
+      throw Error(
+        'The "react" package in this environment is not configured correctly. The "react-server" condition must be enabled in any environment that runs React Server Components.'
+      );
+    var hasOwnProperty = Object.prototype.hasOwnProperty, isArrayImpl = Array.isArray, createTask = console.createTask ? console.createTask : function() {
+      return null;
+    };
+    React = {
+      react_stack_bottom_frame: function(callStackForError) {
+        return callStackForError();
+      }
+    };
+    var specialPropKeyWarningShown;
+    var didWarnAboutElementRef = {};
+    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+      React,
+      UnknownOwner
+    )();
+    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+    var didWarnAboutKeySpread = {};
+    reactJsxRuntime_reactServer_development.Fragment = REACT_FRAGMENT_TYPE;
+    reactJsxRuntime_reactServer_development.jsx = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternalsServer.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        false,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+    reactJsxRuntime_reactServer_development.jsxDEV = function(type, config, maybeKey, isStaticChildren) {
+      var trackActualOwner = 1e4 > ReactSharedInternalsServer.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        isStaticChildren,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+    reactJsxRuntime_reactServer_development.jsxs = function(type, config, maybeKey) {
+      var trackActualOwner = 1e4 > ReactSharedInternalsServer.recentlyCreatedOwnerStacks++;
+      return jsxDEVImpl(
+        type,
+        config,
+        maybeKey,
+        true,
+        trackActualOwner ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
+        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+      );
+    };
+  })();
+  return reactJsxRuntime_reactServer_development;
+}
+var hasRequiredJsxRuntime_reactServer;
+function requireJsxRuntime_reactServer() {
+  if (hasRequiredJsxRuntime_reactServer) return jsxRuntime_reactServer.exports;
+  hasRequiredJsxRuntime_reactServer = 1;
+  if (process.env.NODE_ENV === "production") {
+    jsxRuntime_reactServer.exports = requireReactJsxRuntime_reactServer_production();
+  } else {
+    jsxRuntime_reactServer.exports = requireReactJsxRuntime_reactServer_development();
+  }
+  return jsxRuntime_reactServer.exports;
+}
+var jsxRuntime_reactServerExports = requireJsxRuntime_reactServer();
+export {
+  jsxRuntime_reactServerExports as j
+};