@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/runtime/types/provider.d.ts

@@ -0,0 +1,7 @@
+import type { ValidProviderTypes } from '#blokkli-build/generated-types';
+import type { EntityContext } from '.';
+export type EditPermission = 'view' | 'edit' | 'review' | 'delete';
+export type BlokkliProviderEntityContext = EntityContext & {
+    providerType: ValidProviderTypes;
+    language?: string;
+};

package/dist/runtime/types/vue.d.ts

@@ -0,0 +1 @@
+export type VueClassProp = string | Record<string, boolean> | VueClassProp[];

package/dist/shared/editor.6D5vApr0.mjs

@@ -0,0 +1,30 @@
+function defineCodeTemplate(name, buildCode, buildTypes, options) {
+  return {
+    type: "code",
+    name,
+    buildCode,
+    buildTypes,
+    options: {
+      dependencies: options?.dependencies || [],
+      write: !!options?.write,
+      context: options?.context || "app"
+    }
+  };
+}
+function defineFileTemplate(fileName, build, options) {
+  return {
+    type: "file",
+    fileName,
+    build,
+    options: {
+      dependencies: options?.dependencies || [],
+      write: options?.write ?? true,
+      context: options?.context || "app"
+    }
+  };
+}
+function withHelper(cb) {
+  return cb;
+}
+
+export { defineFileTemplate as a, defineCodeTemplate as d, withHelper as w };

package/dist/shared/editor.9vf8ZnOp.mjs

@@ -0,0 +1,288 @@
+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.None,
+      removeComments: true
+    }
+  });
+  const jsCode = result.outputText.trim();
+  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 onlyUnique(value, index, self) {
+  return self.indexOf(value) === index;
+}
+
+export { Collector as C, CollectedFile as a, extractObjectLiteral as b, extractStringProperty as e, falsy as f, onlyUnique as o, parseTsObject as p, sortObjectKeys as s, toValidVariableName as t };