nuxt-studio 0.0.0

package/dist/module/runtime/utils/activation.js

@@ -0,0 +1,23 @@
+import { getAppManifest, useState, useRuntimeConfig } from "#imports";
+export async function defineStudioActivationPlugin(onStudioActivation) {
+  const user = useState("studio-session", () => null);
+  const config = useRuntimeConfig().public.studio;
+  await $fetch("/__nuxt_studio/auth/session").then((session) => {
+    user.value = session?.user ?? null;
+  });
+  let mounted = false;
+  if (user.value?.email) {
+    const manifest = await getAppManifest();
+    manifest.prerendered = [];
+    await onStudioActivation(user.value);
+    mounted = true;
+  } else if (mounted) {
+    window.location.reload();
+  } else {
+    document.addEventListener("keydown", (event) => {
+      if (event.metaKey && event.key === ".") {
+        window.location.href = config.route;
+      }
+    });
+  }
+}

package/dist/module/runtime/utils/collection.d.ts

@@ -0,0 +1,22 @@
+import type { CollectionInfo, CollectionSource, Draft07, CollectionItemBase, ResolvedCollectionSource } from '@nuxt/content';
+import type { DatabaseItem } from 'nuxt-studio/app';
+export declare const getCollectionByFilePath: (path: string, collections: Record<string, CollectionInfo>) => CollectionInfo | undefined;
+export declare function generateStemFromFsPath(path: string): string;
+export declare function generateIdFromFsPath(path: string, collectionInfo: CollectionInfo): string;
+export declare function getOrderedSchemaKeys(schema: Draft07): string[];
+export declare function getCollection(collectionName: string, collections: Record<string, CollectionInfo>): CollectionInfo;
+export declare function getCollectionSource(id: string, collection: CollectionInfo): ResolvedCollectionSource | undefined;
+export declare function generateFsPathFromId(id: string, source: CollectionInfo['source'][0]): string;
+export declare function getCollectionInfo(id: string, collections: Record<string, CollectionInfo>): {
+    collection: CollectionInfo;
+    source: ResolvedCollectionSource | undefined;
+    fsPath: string;
+};
+export declare function parseSourceBase(source: CollectionSource): {
+    fixed: string;
+    dynamic: string;
+};
+export declare function createCollectionDocument(collection: CollectionInfo, id: string, document: CollectionItemBase): DatabaseItem;
+export declare function normalizeDocument(document: DatabaseItem): DatabaseItem;
+export declare function generateRecordInsert(collection: CollectionInfo, data: Record<string, unknown>): string;
+export declare function generateRecordDeletion(collection: CollectionInfo, id: string): string;

package/dist/module/runtime/utils/collection.js

@@ -0,0 +1,154 @@
+import { hash } from "ohash";
+import { pathMetaTransform } from "./path-meta.js";
+import { minimatch } from "minimatch";
+import { join, dirname, parse } from "pathe";
+import { withoutLeadingSlash } from "ufo";
+export const getCollectionByFilePath = (path, collections) => {
+  let matchedSource;
+  const collection = Object.values(collections).find((collection2) => {
+    if (!collection2.source || collection2.source.length === 0) {
+      return;
+    }
+    const paths = path === "/" ? ["index.yml", "index.yaml", "index.md", "index.json"] : [path];
+    return paths.some((p) => {
+      matchedSource = collection2.source.find((source) => {
+        const include = minimatch(p, source.include, { dot: true });
+        const exclude = source.exclude?.some((exclude2) => minimatch(p, exclude2));
+        return include && !exclude;
+      });
+      return matchedSource;
+    });
+  });
+  return collection;
+};
+export function generateStemFromFsPath(path) {
+  return withoutLeadingSlash(join(dirname(path), parse(path).name));
+}
+export function generateIdFromFsPath(path, collectionInfo) {
+  const { fixed } = parseSourceBase(collectionInfo.source[0]);
+  const pathWithoutFixed = path.substring(fixed.length);
+  return join(collectionInfo.name, collectionInfo.source[0]?.prefix || "", pathWithoutFixed);
+}
+export function getOrderedSchemaKeys(schema) {
+  const shape = Object.values(schema.definitions)[0]?.properties || {};
+  const keys = new Set([
+    shape.id ? "id" : void 0,
+    shape.title ? "title" : void 0,
+    ...Object.keys(shape).sort()
+  ].filter(Boolean));
+  return Array.from(keys);
+}
+export function getCollection(collectionName, collections) {
+  const collection = collections[collectionName];
+  if (!collection) {
+    throw new Error(`Collection ${collectionName} not found`);
+  }
+  return collection;
+}
+export function getCollectionSource(id, collection) {
+  const [_, ...rest] = id.split(/[/:]/);
+  const path = rest.join("/");
+  const matchedSource = collection.source.find((source) => {
+    const include = minimatch(path, source.include, { dot: true });
+    const exclude = source.exclude?.some((exclude2) => minimatch(path, exclude2));
+    return include && !exclude;
+  });
+  return matchedSource;
+}
+export function generateFsPathFromId(id, source) {
+  const [_, ...rest] = id.split(/[/:]/);
+  const path = rest.join("/");
+  const { fixed } = parseSourceBase(source);
+  const pathWithoutFixed = path.substring(fixed.length);
+  return join(fixed, pathWithoutFixed);
+}
+export function getCollectionInfo(id, collections) {
+  const collection = getCollection(id.split(/[/:]/)[0], collections);
+  const source = getCollectionSource(id, collection);
+  const fsPath = generateFsPathFromId(id, source);
+  return {
+    collection,
+    source,
+    fsPath
+  };
+}
+export function parseSourceBase(source) {
+  const [fixPart, ...rest] = source.include.includes("*") ? source.include.split("*") : ["", source.include];
+  return {
+    fixed: fixPart || "",
+    dynamic: "*" + rest.join("*")
+  };
+}
+export function createCollectionDocument(collection, id, document) {
+  const parsedContent = [
+    pathMetaTransform
+  ].reduce((acc, fn) => collection.type === "page" ? fn(acc) : acc, { ...document, id });
+  const result = { id };
+  const meta = parsedContent.meta;
+  const collectionKeys = getOrderedSchemaKeys(collection.schema);
+  for (const key of Object.keys(parsedContent)) {
+    if (collectionKeys.includes(key)) {
+      result[key] = parsedContent[key];
+    } else {
+      meta[key] = parsedContent[key];
+    }
+  }
+  result.meta = meta;
+  if (collectionKeys.includes("seo")) {
+    const seo = result.seo = result.seo || {};
+    seo.title = seo.title || result.title;
+    seo.description = seo.description || result.description;
+  }
+  return result;
+}
+export function normalizeDocument(document) {
+  if (document?.seo) {
+    const seo = document.seo;
+    if (!seo.title || seo.title === document.title) {
+      Reflect.deleteProperty(document.seo, "title");
+    }
+    if (!seo.description || seo.description === document.description) {
+      Reflect.deleteProperty(document.seo, "description");
+    }
+    if (Object.keys(seo).length === 0) {
+      Reflect.deleteProperty(document, "seo");
+    }
+  }
+  return document;
+}
+function computeValuesBasedOnCollectionSchema(collection, data) {
+  const fields = [];
+  const values = [];
+  const properties = collection.schema.definitions[collection.name].properties;
+  const sortedKeys = getOrderedSchemaKeys(collection.schema);
+  sortedKeys.forEach((key) => {
+    const value = properties[key];
+    const type = collection.fields[key];
+    const defaultValue = value?.default !== void 0 ? value.default : "NULL";
+    const valueToInsert = typeof data[key] !== "undefined" ? data[key] : defaultValue;
+    fields.push(key);
+    if (type === "json") {
+      values.push(`'${JSON.stringify(valueToInsert).replace(/'/g, "''")}'`);
+    } else if (type === "string" || ["string", "enum"].includes(value.type)) {
+      if (["data", "datetime"].includes(value.format)) {
+        values.push(valueToInsert !== "NULL" ? `'${new Date(valueToInsert).toISOString()}'` : defaultValue);
+      } else {
+        values.push(`'${String(valueToInsert).replace(/\n/g, "\\n").replace(/'/g, "''")}'`);
+      }
+    } else if (type === "boolean") {
+      values.push(valueToInsert !== "NULL" ? !!valueToInsert : valueToInsert);
+    } else {
+      values.push(valueToInsert);
+    }
+  });
+  values.push(`'${hash(values)}'`);
+  return values;
+}
+export function generateRecordInsert(collection, data) {
+  const values = computeValuesBasedOnCollectionSchema(collection, data);
+  let index = 0;
+  return `INSERT INTO ${collection.tableName} VALUES (${"?, ".repeat(values.length).slice(0, -2)})`.replace(/\?/g, () => values[index++]);
+}
+export function generateRecordDeletion(collection, id) {
+  return `DELETE FROM ${collection.tableName} WHERE id = '${id}';`;
+}

package/dist/module/runtime/utils/ensure.d.ts

@@ -0,0 +1 @@
+export declare function ensure(check: () => boolean, timeout?: number, maxTries?: number): Promise<unknown>;

package/dist/module/runtime/utils/ensure.js

@@ -0,0 +1,22 @@
+export function ensure(check, timeout = 50, maxTries = 20) {
+  return new Promise((resolve, reject) => {
+    _ensureWithCallback(check, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(true);
+      }
+    }, timeout, maxTries);
+  });
+}
+function _ensureWithCallback(check, callback, timeout = 50, maxTries = 20) {
+  if (check()) {
+    return callback(void 0);
+  }
+  setTimeout(() => {
+    _ensureWithCallback(check, callback, timeout, maxTries - 1);
+  }, timeout);
+  if (maxTries === 0) {
+    callback(new Error("Max tries reached"));
+  }
+}

package/dist/module/runtime/utils/object.d.ts

@@ -0,0 +1,3 @@
+export declare const omit: (obj: Record<string, unknown>, keys: string | string[]) => {
+    [k: string]: unknown;
+};

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

@@ -0,0 +1,3 @@
+export const omit = (obj, keys) => {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+};

package/dist/module/runtime/utils/path-meta.d.ts

@@ -0,0 +1,50 @@
+import type { PageCollectionItemBase } from '@nuxt/content';
+export interface PathMetaOptions {
+    slugifyOptions?: {
+        lower?: boolean;
+    };
+}
+export declare function pathMetaTransform(content: PageCollectionItemBase, options?: PathMetaOptions): {
+    title: string;
+    stem: string;
+    extension: string;
+    path: string;
+    description: string;
+    seo: {
+        title?: string;
+        description?: string;
+        [key: string]: unknown;
+    };
+    body: import("@nuxt/content").MarkdownRoot;
+    navigation?: boolean | {
+        title: string;
+        description: string;
+        icon: string;
+    };
+    id: string;
+    meta: Record<string, unknown>;
+};
+/**
+ * Generate path from file name
+ *
+ * @param path file full path
+ * @returns generated slug
+ */
+export declare const generatePath: (path: string, { forceLeadingSlash, slugifyOptions }?: {
+    forceLeadingSlash?: boolean | undefined;
+    slugifyOptions?: {} | undefined;
+}) => string;
+/**
+ * generate title from file path
+ */
+export declare const generateTitle: (path: string) => string;
+/**
+ * Clean up special keywords from path part
+ */
+export declare function refineUrlPart(name: string): string;
+export declare const describeId: (id: string) => {
+    source: string | undefined;
+    stem: string;
+    extension: string;
+    basename: string;
+};

package/dist/module/runtime/utils/path-meta.js

@@ -0,0 +1,49 @@
+import { pascalCase } from "scule";
+import slugify from "slugify";
+import { withoutTrailingSlash, withLeadingSlash } from "ufo";
+import defu from "defu";
+const SEMVER_REGEX = /^\d+(?:\.\d+)*(?:\.x)?$/;
+const defaultOptions = {
+  slugifyOptions: {
+    lower: true
+  }
+};
+export function pathMetaTransform(content, options = {}) {
+  const opts = defu(options, defaultOptions);
+  const { basename, extension, stem } = describeId(content.id);
+  const filePath = generatePath(stem, opts);
+  return {
+    // @ts-expect-error - duplicate key
+    path: filePath,
+    ...content,
+    title: content.title || generateTitle(refineUrlPart(basename)),
+    stem,
+    extension
+  };
+}
+export const generatePath = (path, { forceLeadingSlash = true, slugifyOptions = {} } = {}) => {
+  path = path.split("/").map((part) => slugify(refineUrlPart(part), slugifyOptions)).join("/");
+  return forceLeadingSlash ? withLeadingSlash(withoutTrailingSlash(path)) : path;
+};
+export const generateTitle = (path) => path.split(/[\s-]/g).map(pascalCase).join(" ");
+export function refineUrlPart(name) {
+  name = name.split(/[/:]/).pop();
+  if (SEMVER_REGEX.test(name)) {
+    return name;
+  }
+  return name.replace(/(\d+\.)?(.*)/, "$2").replace(/^index(\.draft)?$/, "").replace(/\.draft$/, "");
+}
+export const describeId = (id) => {
+  const [source, ...parts] = id.split(/[:/]/);
+  const [, basename, extension] = parts[parts.length - 1]?.match(/(.*)\.([^.]+)$/) || [];
+  if (basename) {
+    parts[parts.length - 1] = basename;
+  }
+  const stem = (parts || []).join("/");
+  return {
+    source,
+    stem,
+    extension,
+    basename: basename || ""
+  };
+};

package/dist/module/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.mjs'

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "nuxt-studio",
+  "version": "0.0.0",
+  "description": "Nuxt Studio for Nuxt Content",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuxt-content/studio.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./dist/module/module.mjs",
+    "./app": {
+      "types": "./dist/app/main.d.ts",
+      "default": "./dist/app/main.js"
+    },
+    "./app/utils": {
+      "types": "./dist/app/shared.d.ts",
+      "default": "./dist/app/shared.js"
+    },
+    "./app/service-worker": {
+      "types": "./dist/app/service-worker.d.ts",
+      "default": "./dist/app/service-worker.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/module/module.mjs",
+  "scripts": {
+    "prepack": "nuxt-module-build build src/module; vite build src/app",
+    "dev": "pnpm run dev:prepare && STUDIO_DEV_SERVER=http://localhost:5151 nuxi dev playground/docus",
+    "dev:minimal": "pnpm run dev:prepare && STUDIO_DEV_SERVER=http://localhost:5151 nuxt dev playground/minimal",
+    "dev:app": "vite src/app --port 5151",
+    "dev:build": "nuxi build playground/docus",
+    "dev:prepare": "nuxt-module-build build --stub src/module && nuxt-module-build prepare src/module && nuxi prepare playground/docus",
+    "release": "release-it --preRelease=alpha --npm.tag=alpha",
+    "lint": "eslint .",
+    "typecheck": "nuxt typecheck && vue-tsc -p src/app/tsconfig.app.json",
+    "verify": "pnpm run dev:prepare && pnpm run lint && pnpm run prepack && pnpm run typecheck && pnpm run test",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground/docus && vue-tsc --noEmit"
+  },
+  "dependencies": {
+    "@iconify-json/lucide": "^1.2.72",
+    "@nuxtjs/mdc": "^0.18.2",
+    "@vueuse/core": "^13.9.0",
+    "defu": "^6.1.4",
+    "destr": "^2.0.5",
+    "unstorage": "1.17.1"
+  },
+  "devDependencies": {
+    "@iconify-json/simple-icons": "^1.2.57",
+    "@nuxt/content": "^3.8.0",
+    "@nuxt/eslint-config": "^1.10.0",
+    "@nuxt/kit": "^4.2.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/ui": "^4.1.0",
+    "@octokit/types": "^15.0.1",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "@tailwindcss/typography": "^0.5.19",
+    "@types/js-yaml": "^4.0.9",
+    "@unhead/vue": "^2.0.19",
+    "@unpic/vue": "^1.0.0",
+    "@vitejs/plugin-vue": "^6.0.1",
+    "eslint": "^9.39.1",
+    "idb-keyval": "^6.2.2",
+    "minimark": "^0.2.0",
+    "modern-monaco": "^0.2.2",
+    "nuxt-studio": "workspace:*",
+    "ofetch": "^1.5.1",
+    "release-it": "^19.0.5",
+    "tailwindcss": "^4.1.16",
+    "vite": "^7.1.12",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-libcss": "^1.1.2",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.22",
+    "vue-router": "^4.6.3",
+    "vue-tsc": "^3.1.3",
+    "zod": "^4.1.12"
+  },
+  "resolutions": {
+    "remark-mdc": "3.8.1"
+  },
+  "packageManager": "pnpm@10.20.0",
+  "keywords": [
+    "nuxt",
+    "content",
+    "nuxt-module",
+    "studio",
+    "editor",
+    "preview",
+    "cms",
+    "markdown",
+    "mdc"
+  ]
+}