@revenexx/editor 0.1.0

package/dist/shared/editor.Gu7mgJ5Q.mjs

@@ -0,0 +1,320 @@
+import * as ts from 'typescript';
+import { parseAndWalk } from 'oxc-walker';
+
+class CollectedFile {
+  constructor(filePath, fileContents) {
+    this.filePath = filePath;
+    this.fileContents = fileContents;
+  }
+  async handleChange(_helper) {
+    return Promise.resolve(true);
+  }
+  /**
+   * Validate the collected file and return any errors.
+   * Override this method in subclasses to add validation logic.
+   */
+  validate(_icons) {
+    return [];
+  }
+}
+class Collector {
+  constructor(helper) {
+    this.helper = helper;
+    this.files = /* @__PURE__ */ new Map();
+  }
+  files;
+  needsFileContents = true;
+  async addFile(filePath) {
+    if (this.needsFileContents) {
+      const contents = await this.helper.fileCache.read(filePath);
+      const file = this.createCollectedFile(filePath, contents.toString());
+      await file.handleChange(this.helper);
+      this.files.set(filePath, file);
+    } else {
+      const file = this.createCollectedFile(filePath);
+      await file.handleChange(this.helper);
+      this.files.set(filePath, file);
+    }
+  }
+  async handleAdd(filePath) {
+    const applies = await this.applies(filePath);
+    if (applies) {
+      await this.addFile(filePath);
+      return true;
+    }
+    return false;
+  }
+  async handleChange(filePath) {
+    const applies = await this.applies(filePath);
+    if (!applies) {
+      return this.handleUnlink(filePath);
+    }
+    const file = this.files.get(filePath);
+    if (!file) {
+      return false;
+    }
+    if (this.needsFileContents) {
+      const contents = await this.helper.fileCache.read(filePath);
+      file.fileContents = contents.toString();
+      return await file.handleChange(this.helper);
+    }
+    return true;
+  }
+  handleUnlink(filePath) {
+    if (this.files.has(filePath)) {
+      this.files.delete(filePath);
+      return true;
+    }
+    return false;
+  }
+  handleAddDir() {
+    return false;
+  }
+  handleUnlinkDir(folderPath) {
+    const allKeys = [...this.files.keys()];
+    const toRemove = allKeys.filter((filePath) => filePath.includes(folderPath));
+    if (toRemove.length) {
+      toRemove.forEach((key) => this.files.delete(key));
+      return true;
+    }
+    return false;
+  }
+  async handleWatchEvent(event, filePath) {
+    let hasChanged = false;
+    if (event === "add") {
+      hasChanged = await this.handleAdd(filePath);
+    } else if (event === "change") {
+      hasChanged = await this.handleChange(filePath);
+    } else if (event === "unlink") {
+      hasChanged = await this.handleUnlink(filePath);
+    } else if (event === "addDir") {
+      hasChanged = this.handleAddDir();
+    } else if (event === "unlinkDir") {
+      hasChanged = this.handleUnlinkDir(filePath);
+    }
+    return { hasChanged };
+  }
+  /**
+   * Validate all collected files and log any errors/warnings to the console.
+   * @returns true if there are validation errors (not warnings), false otherwise.
+   */
+  validate(icons) {
+    const allIssues = [];
+    for (const file of this.files.values()) {
+      const issues = file.validate(icons);
+      if (issues.length > 0) {
+        allIssues.push({ filePath: file.filePath, issues });
+      }
+    }
+    if (allIssues.length === 0) {
+      return false;
+    }
+    const errors = [];
+    const warnings = [];
+    for (const { filePath, issues } of allIssues) {
+      const fileErrors = issues.filter((i) => i.severity !== "warning");
+      const fileWarnings = issues.filter((i) => i.severity === "warning");
+      if (fileErrors.length > 0) {
+        errors.push({ filePath, issues: fileErrors });
+      }
+      if (fileWarnings.length > 0) {
+        warnings.push({ filePath, issues: fileWarnings });
+      }
+    }
+    if (warnings.length > 0) {
+      const lines = warnings.flatMap(({ filePath, issues }) => [
+        `  ${filePath}:`,
+        ...issues.map((e) => `    - ${e.message}`)
+      ]);
+      this.helper.logger.warn(
+        `bl\xF6kkli validation warnings:
+${lines.join("\n")}`
+      );
+    }
+    if (errors.length > 0) {
+      const lines = errors.flatMap(({ filePath, issues }) => [
+        `  ${filePath}:`,
+        ...issues.map((e) => `    - ${e.message}`)
+      ]);
+      this.helper.logger.error(
+        `bl\xF6kkli validation errors:
+${lines.join("\n")}`
+      );
+      return true;
+    }
+    return false;
+  }
+}
+
+function sortObjectKeys(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(sortObjectKeys);
+  } else if (obj && typeof obj === "object") {
+    const sortedObj = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+      sortedObj[key] = sortObjectKeys(obj[key]);
+    }
+    return sortedObj;
+  }
+  return obj;
+}
+function toValidVariableName(input) {
+  let result = input.replace(/\W/g, "_");
+  if (/^\d/.test(result)) {
+    result = "_" + result;
+  }
+  if (result === "") {
+    result = "_empty";
+  }
+  return result;
+}
+function parseTsObject(tsObjectStr) {
+  const source = `(${tsObjectStr})`;
+  const result = ts.transpileModule(source, {
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      removeComments: true
+    }
+  });
+  const jsCode = result.outputText.trim().replace(/^(?:["'][^"'\n]*["']\s*;?\s*)+/, "");
+  const createObj = new Function(`return ${jsCode}`);
+  const object = createObj();
+  return { object, source: jsCode };
+}
+function falsy(value) {
+  return value !== null && value !== void 0;
+}
+const SFC_SCRIPT_RE = /<script(?<attrs>[^>]*)>(?<content>[\s\S]*?)<\/script[^>]*>/gi;
+function extractScriptContent(sfc) {
+  const contents = [];
+  let hasMatch = false;
+  for (const match of sfc.matchAll(SFC_SCRIPT_RE)) {
+    hasMatch = true;
+    if (match?.groups?.content) {
+      contents.push({
+        loader: match.groups.attrs && /[tj]sx/.test(match.groups.attrs) ? "tsx" : "ts",
+        code: match.groups.content.trim()
+      });
+    }
+  }
+  if (!hasMatch) {
+    contents.push({
+      loader: "ts",
+      code: sfc.trim()
+    });
+  }
+  return contents;
+}
+function extractObjectLiteral(fileContents, composables) {
+  if (!composables.some((composable) => fileContents.includes(composable))) {
+    return void 0;
+  }
+  const scripts = extractScriptContent(fileContents);
+  for (const script of scripts) {
+    try {
+      let result;
+      const filename = script.loader === "tsx" ? "temp.tsx" : "temp.ts";
+      parseAndWalk(script.code, filename, {
+        parseOptions: {
+          range: true
+        },
+        enter(node) {
+          if (result) return;
+          if (node.type === "CallExpression" && node.callee.type === "Identifier" && composables.includes(node.callee.name)) {
+            for (const arg of node.arguments) {
+              if (arg.type === "ObjectExpression" && arg.range) {
+                result = script.code.substring(arg.range[0], arg.range[1]);
+                break;
+              }
+            }
+          }
+        }
+      });
+      if (result) {
+        return result;
+      }
+    } catch (error) {
+      console.log(error);
+      continue;
+    }
+  }
+  return void 0;
+}
+function extractStringProperty(fileContents, composables, propertyName) {
+  if (!composables.some((composable) => fileContents.includes(composable))) {
+    return void 0;
+  }
+  const scripts = extractScriptContent(fileContents);
+  for (const script of scripts) {
+    try {
+      let result;
+      const filename = script.loader === "tsx" ? "temp.tsx" : "temp.ts";
+      parseAndWalk(script.code, filename, {
+        parseOptions: {
+          range: true
+        },
+        enter(node) {
+          if (result) return;
+          if (node.type === "CallExpression" && node.callee.type === "Identifier" && composables.includes(node.callee.name)) {
+            for (const arg of node.arguments) {
+              if (arg.type === "ObjectExpression") {
+                for (const prop of arg.properties) {
+                  if (prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === propertyName && prop.value.type === "Literal" && typeof prop.value.value === "string") {
+                    result = prop.value.value;
+                    break;
+                  }
+                }
+                break;
+              }
+            }
+          }
+        }
+      });
+      if (result) {
+        return result;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function extractFirstStringArg(fileContents, composables) {
+  if (!composables.some((composable) => fileContents.includes(composable))) {
+    return void 0;
+  }
+  const scripts = extractScriptContent(fileContents);
+  for (const script of scripts) {
+    try {
+      let result;
+      const filename = script.loader === "tsx" ? "temp.tsx" : "temp.ts";
+      parseAndWalk(script.code, filename, {
+        parseOptions: {
+          range: true
+        },
+        enter(node) {
+          if (result) return;
+          if (node.type === "CallExpression" && node.callee.type === "Identifier" && composables.includes(node.callee.name)) {
+            const first = node.arguments[0];
+            if (first && first.type === "Literal" && typeof first.value === "string") {
+              result = first.value;
+            }
+          }
+        }
+      });
+      if (result) {
+        return result;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function onlyUnique(value, index, self) {
+  return self.indexOf(value) === index;
+}
+
+export { Collector as C, CollectedFile as a, extractStringProperty as b, extractObjectLiteral as c, extractFirstStringArg as e, falsy as f, onlyUnique as o, parseTsObject as p, sortObjectKeys as s, toValidVariableName as t };

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { ModuleHooks } from './module.mjs'
+
+declare module '@nuxt/schema' {
+  interface NuxtHooks extends ModuleHooks {}
+}
+
+export { type ModuleHooks } from './shared/editor.D28NbXr3.mjs'
+
+export { type ModuleOptions, default } from './module.mjs'

package/package.json

@@ -0,0 +1,298 @@
+{
+  "name": "@revenexx/editor",
+  "version": "0.1.0",
+  "description": "revenexx hard fork of blökkli — interactive page building experience for Nuxt. Independently versioned; the upstream base of each release is documented in FORK.md.",
+  "keywords": [
+    "cms",
+    "drag-and-drop",
+    "editor",
+    "nuxt",
+    "nuxt-module",
+    "page-builder",
+    "vue",
+    "wysiwyg"
+  ],
+  "homepage": "https://blokk.li",
+  "bugs": {
+    "url": "https://github.com/revenexx/blokkli/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Jan Hug",
+    "email": "me@dulnan.net",
+    "url": "https://dulnan.net"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/revenexx/blokkli.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ],
+      "agent": [
+        "./dist/modules/agent/index.d.mts"
+      ],
+      "table-of-contents": [
+        "./dist/modules/table-of-contents/index.d.mts"
+      ],
+      "charts": [
+        "./dist/modules/charts/index.d.mts"
+      ],
+      "iframes": [
+        "./dist/modules/iframes/index.d.mts"
+      ],
+      "modules": [
+        "./dist/modules/index.d.mts"
+      ],
+      "tailwind": [
+        "./dist/modules/tailwind/index.d.mts"
+      ],
+      "readability": [
+        "./dist/modules/readability/index.d.mts"
+      ]
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./agent": {
+      "types": "./dist/modules/agent/index.d.mts",
+      "import": "./dist/modules/agent/index.mjs"
+    },
+    "./table-of-contents": {
+      "types": "./dist/modules/table-of-contents/index.d.mts",
+      "import": "./dist/modules/table-of-contents/index.mjs"
+    },
+    "./charts": {
+      "types": "./dist/modules/charts/index.d.mts",
+      "import": "./dist/modules/charts/index.mjs"
+    },
+    "./iframes": {
+      "types": "./dist/modules/iframes/index.d.mts",
+      "import": "./dist/modules/iframes/index.mjs"
+    },
+    "./modules": {
+      "types": "./dist/modules/index.d.mts",
+      "import": "./dist/modules/index.mjs"
+    },
+    "./tailwind": {
+      "types": "./dist/modules/tailwind/index.d.mts",
+      "require": "./dist/modules/tailwind/index.mjs",
+      "import": "./dist/modules/tailwind/index.mjs"
+    },
+    "./readability": {
+      "types": "./dist/modules/readability/index.d.mts",
+      "require": "./dist/modules/readability/index.mjs",
+      "import": "./dist/modules/readability/index.mjs"
+    }
+  },
+  "scripts": {
+    "prepack": "rm -rf dist && nuxt-module-build build && npx tsx scripts/mangle-dist.ts",
+    "dev": "nuxi dev playground --host",
+    "typecheck": "npm run typecheck:build && npm run typecheck:runtime && npm run typecheck:server && npm run typecheck:playground",
+    "typecheck:build": "vue-tsc --noEmit -p .nuxt/tsconfig.node.json",
+    "typecheck:runtime": "vue-tsc --noEmit -p .nuxt/tsconfig.app.json",
+    "typecheck:server": "vue-tsc --noEmit -p .nuxt/tsconfig.server.json",
+    "typecheck:playground": "vue-tsc --noEmit -p ./playground/.nuxt/tsconfig.app.json",
+    "dev:minimal": "nuxi dev playground-minimal --host",
+    "styles:build": "postcss ./css/index.css -o ./src/runtime/editor/css/output.css",
+    "styles:watch": "postcss ./css/index.css -o ./src/runtime/editor/css/output.css --watch",
+    "dev:build": "npm run changelog && npm run dev:prepare && nuxi generate playground",
+    "dev:build-ssr": "PLAYGROUND_SSR_BUILD=true nuxt build playground",
+    "dev:start": "npx serve playground/.output/public",
+    "dev:start-ssr": "cd playground && node -r dotenv/config ./.output/server/index.mjs",
+    "dev:prepare": "PLAYGROUND_MODULE_BUILD=true nuxt-module-build build --stub && PLAYGROUND_MODULE_BUILD=true nuxt-module-build prepare && nuxi prepare playground",
+    "dev:analyze": "npx nuxt analyze playground",
+    "release": "npm run lint && npm run prepack && changelogen --release",
+    "changelog": "node ./scripts/changelog/index.cjs",
+    "texts": "node ./scripts/texts/index.cjs",
+    "material-icons": "node ./scripts/material-icons/index.cjs",
+    "lint": "npx oxlint && eslint ./src",
+    "lint:fix": "npx oxlint --fix && eslint ./src --fix",
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:watch": "vitest watch --project unit --project e2e --no-file-parallelism",
+    "test:unit": "vitest run --project unit",
+    "test:unit:watch": "vitest watch --project unit",
+    "test:e2e": "vitest run --project e2e",
+    "format": "prettier . --check",
+    "format:fix": "prettier . --write",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "dependencies": {
+    "@floating-ui/dom": "^1.7.6",
+    "@material-symbols/svg-600": "0.40.2",
+    "@tiptap/core": "^3.22.5",
+    "@tiptap/extension-emoji": "^3.22.5",
+    "@tiptap/extension-mention": "^3.22.5",
+    "@tiptap/extension-task-item": "^3.22.5",
+    "@tiptap/extension-task-list": "^3.22.5",
+    "@tiptap/pm": "^3.22.5",
+    "@tiptap/starter-kit": "^3.22.5",
+    "@tiptap/suggestion": "^3.22.5",
+    "@tiptap/vue-3": "^3.22.5",
+    "artboard-deluxe": "^0.1.5",
+    "echarts": "^6.0.0",
+    "estree-walker-ts": "^1.1.0",
+    "fzf": "^0.5.2",
+    "get-video-id": "^4.1.7",
+    "html-diff-ts": "^1.4.2",
+    "json5": "^2.2.3",
+    "marked": "^17.0.1",
+    "mitt": "^3.0.1",
+    "papaparse": "^5.5.3",
+    "pofile": "^1.1.4",
+    "qrcode.vue": "^3.6.0",
+    "twgl.js": "^7.0.0",
+    "vue-echarts": "^8.0.1",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@ckeditor/ckeditor5-vue": "^8.0.0",
+    "@iconify-json/solar": "^1.2.5",
+    "@iconify/utils": "^3.1.3",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.12.1",
+    "@nuxt/kit": "^4.4.4",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^4.4.4",
+    "@nuxt/test-utils": "^3.21.0",
+    "@tailwindcss/forms": "^0.5.11",
+    "@tailwindcss/postcss": "^4.2.4",
+    "@tailwindcss/typography": "^0.5.19",
+    "@tailwindcss/vite": "^4.2.4",
+    "@thedutchcoder/postcss-rem-to-px": "^0.0.2",
+    "@types/gettext-parser": "^8.0.0",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "^25.0.3",
+    "@types/papaparse": "^5.5.2",
+    "@types/turndown": "^5.0.5",
+    "@vue/test-utils": "^2.4.6",
+    "axe-core": "^4.11.0",
+    "changelogen": "^0.6.2",
+    "ckeditor5": "^48.1.1",
+    "commander": "^13.1.0",
+    "deepl-node": "^1.25.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-oxlint": "^1.35.0",
+    "eslint-plugin-sonarjs": "^3.0.5",
+    "eslint-plugin-tailwindcss": "^4.0.0-beta.0",
+    "gettext-parser": "^8.0.0",
+    "happy-dom": "^20.0.11",
+    "nuxt": "^4.4.4",
+    "nuxt-graphql-middleware": "^5.3.0",
+    "nuxt-svg-icon-sprite": "^2.0.2",
+    "openai": "^6.17.0",
+    "oxc-parser": "^0.98.0",
+    "oxc-walker": "^0.7.0",
+    "oxfmt": "^0.20.0",
+    "oxlint": "^1.35.0",
+    "playwright-core": "^1.57.0",
+    "postcss": "^8.5.6",
+    "postcss-cli": "^11.0.1",
+    "postcss-import": "^16.1.1",
+    "postcss-mixins": "^12.1.2",
+    "postcss-nested-import": "^1.3.0",
+    "postcss-nesting": "^14.0.0",
+    "postcss-replace": "^2.0.1",
+    "postcss-selector-parser": "^7.1.1",
+    "postcss-url": "^10.1.3",
+    "prettier": "^3.7.4",
+    "prettier-plugin-glsl": "^0.2.5",
+    "syllable": "^5.0.1",
+    "tailwindcss": "^4.2.4",
+    "tsx": "^4.21.0",
+    "turndown": "^7.2.4",
+    "typescript": "^6.0.0",
+    "unbuild": "^3.6.1",
+    "vite-plugin-glsl": "^1.5.5",
+    "vitepress": "^2.0.0-alpha.17",
+    "vitest": "^3.2.4",
+    "vue-router": "^5.0.7",
+    "vue-tsc": "^3.1.8"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": "*",
+    "@thedutchcoder/postcss-rem-to-px": "*",
+    "acorn": "^8.0.0",
+    "axe-core": "*",
+    "esbuild": ">=0.20.0",
+    "magic-string": ">=0.30.0",
+    "mammoth": "^1.11.0",
+    "micromatch": "^4.0.0",
+    "openai": "*",
+    "oxc-walker": ">=0.5.0",
+    "postcss": "*",
+    "postcss-import": "*",
+    "postcss-replace": "*",
+    "syllable": "*",
+    "tailwindcss": "*",
+    "turndown": "^7.2.2",
+    "typescript": "^5.0.0 || ^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "syllable": {
+      "optional": true
+    },
+    "@thedutchcoder/postcss-rem-to-px": {
+      "optional": true
+    },
+    "axe-core": {
+      "optional": true
+    },
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "postcss": {
+      "optional": true
+    },
+    "postcss-import": {
+      "optional": true
+    },
+    "postcss-replace": {
+      "optional": true
+    },
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "overrides": {
+    "lodash": "^4.17.24",
+    "vue": "^3.5.34",
+    "@nuxt/module-builder": {
+      "typescript": "$typescript"
+    },
+    "postcss-url": {
+      "minimatch": "^10.2.3"
+    },
+    "eslint-plugin-sonarjs": {
+      "minimatch": "^10.2.3"
+    },
+    "prettier-plugin-glsl": {
+      "chevrotain": "^12.0.0",
+      "lodash": "^4.17.24"
+    }
+  }
+}