@blokkli/editor 2.0.0-alpha.31 → 2.0.0-alpha.33

package/dist/runtime/editor/types/app.d.ts

@@ -1,6 +1,6 @@
 import type { ComputedRef } from 'vue';
 import type { DomProvider } from '../providers/dom.js';
-import type { AdapterContext, BlokkliAdapter } from '#blokkli/editor/adapter';
+import type { AdapterContext, FullBlokkliAdapter } from '#blokkli/editor/adapter';
 import type { Eventbus } from '../events/index.js';
 import type { StorageProvider } from '../providers/storage.js';
 import type { BlockDefinitionProvider } from '../providers/types.js';
@@ -25,11 +25,17 @@ import type { TourProvider } from '../providers/tour.js';
 import type { DropAreaProvider } from '../providers/dropArea.js';
 import type { ThemeProvider } from '../providers/theme.js';
 import type { DefinitionProvider } from '../providers/definition.js';
+import type { PermissionsProvider } from '../providers/permissions.js';
+import type { AdaptersProvider } from '../providers/adapters.js';
 export interface BlokkliApp {
     /**
      * The adapter.
      */
-    adapter: BlokkliAdapter<any>;
+    adapter: FullBlokkliAdapter<any>;
+    /**
+     * The adapters provider for accessing base adapter and extensions.
+     */
+    adapters: AdaptersProvider;
     eventBus: Eventbus;
     dom: DomProvider;
     storage: StorageProvider;
@@ -56,4 +62,5 @@ export interface BlokkliApp {
     directive: DirectiveProvider;
     fields: FieldsProvider;
     icons: IconsProvider;
+    permissions: PermissionsProvider;
 }

package/dist/runtime/editor/types/definitions.d.ts

@@ -2,6 +2,7 @@ export interface BlockBundleDefinition {
     id: string;
     label: string;
     description?: string;
+    imageUrl?: string;
     allowReusable?: boolean;
     isTranslatable?: boolean;
     hasPublishOn?: boolean;
@@ -16,3 +17,7 @@ export type FieldConfig = {
     canEdit: boolean;
     allowedBundles: string[];
 };
+export type EntityTypeRestriction = {
+    type: string;
+    bundles: string[];
+};

package/dist/runtime/editor/types/features.d.ts

@@ -2,8 +2,10 @@ import type { BlokkliIcon } from '#blokkli-build/icons';
 import type { FeatureDefinitionBase, FeatureDefinitionSettingCheckbox, FeatureDefinitionSettingMethod, FeatureDefinitionSettingRadios, FeatureDefinitionSettingSlider } from './../../../global/types/features.js';
 import type { AdapterMethods } from '#blokkli/editor/adapter';
 import type { BlokkliApp } from './app.js';
+import type { UserPermissions } from './permissions.js';
 export type FeatureDefinitionSetting = FeatureDefinitionSettingCheckbox | FeatureDefinitionSettingRadios<BlokkliIcon> | FeatureDefinitionSettingMethod<BlokkliApp> | FeatureDefinitionSettingSlider;
-export type FeatureDefinition<Methods extends AdapterMethods[] = [], T extends string = ''> = Omit<FeatureDefinitionBase<AdapterMethods, BlokkliIcon, T>, 'requiredAdapterMethods' | 'settings'> & {
+export type FeatureDefinition<Methods extends AdapterMethods[] = [], T extends string = ''> = Omit<FeatureDefinitionBase<AdapterMethods, BlokkliIcon, T>, 'requiredAdapterMethods' | 'settings' | 'requiredPermissions'> & {
     requiredAdapterMethods?: [...Methods];
     settings?: Record<string, FeatureDefinitionSetting>;
+    requiredPermissions?: UserPermissions[];
 };

package/dist/runtime/editor/types/permissions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Map of permission keys to their descriptions.
+ *
+ * Features can augment this interface to register additional permissions:
+ *
+ * ```ts
+ * declare module '#blokkli/editor/types/permissions' {
+ *   interface UserPermissionMap {
+ *     my_permission: 'Description of what this permission grants.'
+ *   }
+ * }
+ * ```
+ */
+export interface UserPermissionMap {
+    use_blokkli: 'use the blökkli editor';
+}
+export type UserPermissions = keyof UserPermissionMap;

package/dist/runtime/helpers/runtimeHelpers/index.d.ts

@@ -1,9 +1,10 @@
 /**
  * This file should contain all helpers that are meant for runtime functionality, such as defineBlokkli composable or <BlokkliProvider>.
  */
-import { type RuntimeBlockOptionArray, type RuntimeBlockOptions } from '#blokkli-build/runtime-options';
+import { type RuntimeBlockOptions } from '#blokkli-build/runtime-options';
 import type { FieldListItemTyped } from '#blokkli-build/generated-types';
 import type { BlockOptionDefinition } from '#blokkli/types/blockOptions';
+import type { RuntimeBlockOptionArray } from '../../../global/types/blockOptions.js';
 import type { FieldListItem } from '#blokkli/types';
 /**
  * Map all kinds of truthy values for a checkbox.

package/dist/runtime/helpers/runtimeHelpers/index.js

@@ -26,38 +26,76 @@ export function getRuntimeOptionValue(definition, value) {
   if ((value === null || value === void 0) && defaultValue !== void 0) {
     return defaultValue;
   }
+  const validationData = Array.isArray(definition) ? definition[2] : void 0;
   if (type === "checkbox") {
     return mapCheckboxTrue(value) === "1";
   } else if (type === "radios") {
     if (typeof value === "string") {
+      const allowedKeys = validationData;
+      if (allowedKeys && allowedKeys.length > 0 && !allowedKeys.includes(value)) {
+        return defaultValue ?? "";
+      }
       return value;
     }
   } else if (type === "checkboxes") {
+    let values = [];
     if (typeof value === "string") {
-      return value.split(",");
+      values = value.split(",");
     } else if (Array.isArray(value)) {
-      return value;
+      values = value;
+    }
+    const allowedKeys = validationData;
+    if (allowedKeys && allowedKeys.length > 0) {
+      values = values.filter((v) => allowedKeys.includes(v));
     }
+    if (values.length > 0) {
+      return values;
+    }
+    return defaultValue ?? [];
   } else if (type === "range" || type === "number") {
+    let numValue;
     if (typeof value === "number" && !Number.isNaN(value)) {
-      return value;
+      numValue = value;
     } else if (typeof value === "string") {
       const parsed = Number.parseFloat(value);
       if (!Number.isNaN(parsed)) {
-        return parsed;
+        numValue = parsed;
+      }
+    }
+    if (numValue !== void 0) {
+      const bounds = validationData;
+      if (bounds) {
+        const [min, max] = bounds;
+        if (min !== void 0 && numValue < min) {
+          numValue = min;
+        }
+        if (max !== void 0 && numValue > max) {
+          numValue = max;
+        }
       }
+      return numValue;
     }
   } else if (type === "color") {
     if (typeof value === "string") {
-      if (value.startsWith("#")) {
+      if (/^#[0-9a-f]{6}$/i.test(value)) {
         return value;
-      } else if (value.length === 6) {
+      } else if (/^[0-9a-f]{6}$/i.test(value)) {
         return `#${value}`;
       }
     }
   } else if (type === "text" && typeof value === "string") {
     return value;
   } else if (type === "datetime-local" && typeof value === "string" && isValidDatetimeLocalValue(value)) {
+    const bounds = validationData;
+    if (bounds) {
+      const [min, max] = bounds;
+      if (min && value < min) {
+        return defaultValue ?? "";
+      }
+      if (max && value > max) {
+        return defaultValue ?? "";
+      }
+    }
     return value;
   }
   if (defaultValue === void 0) {

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

@@ -5,5 +5,11 @@ export type EntityContext = {
     type: string;
     bundle: string;
 };
+export type EntityMetadata = {
+    description: string | null;
+    createdBy: string | null;
+    dateUpdated: string | null;
+    dateCreated: string | null;
+};
 declare const _default: {};
 export default _default;

package/dist/shared/editor.CGf7C_0M.mjs

@@ -0,0 +1,10 @@
+function defineBlokkliModule(init) {
+  return function(options) {
+    return {
+      options,
+      init
+    };
+  };
+}
+
+export { defineBlokkliModule as d };

package/dist/shared/editor.DMFfaLVE.mjs

@@ -0,0 +1,175 @@
+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 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 { Collector as C, CollectedFile as a, defineFileTemplate as b, defineCodeTemplate as d, withHelper as w };

package/dist/shared/{editor.BKQCh70G.d.mts → editor.Iax3GCvt.d.mts}

@@ -6,23 +6,40 @@ import { Resolver } from '@nuxt/kit';
 import { FeatureDefinitionBase } from '../../dist/global/types/features.js';
 
 type TemplateCallback = (context: ModuleContext) => string | Promise<string>;
-type TemplateDependency = 'icons' | 'features' | 'block-content' | 'block-path' | 'block-global-options';
+type TemplateDependency = 'icons' | 'features' | 'block-content' | 'block-path' | 'block-global-options' | 'agent-mcp-tools' | 'agent-server' | 'agent-prompts';
+/**
+ * Where the template should be available:
+ * - 'app': Only in app context (default)
+ * - 'server': Only in server/Nitro context (will be inlined for Nitro build)
+ * - 'both': Available in both contexts
+ */
+type TemplateContext = 'app' | 'server' | 'both';
 type TemplateOptions = {
     dependencies?: TemplateDependency[];
     write?: boolean;
+    /**
+     * The context where this template should be available.
+     * Server templates will be inlined for Nitro build.
+     * @default 'app'
+     */
+    context?: TemplateContext;
 };
 type ModuleCodeTemplate = {
     type: 'code';
     name: string;
     buildCode: TemplateCallback;
     buildTypes: TemplateCallback;
-    options: Required<TemplateOptions>;
+    options: Required<TemplateOptions> & {
+        context: TemplateContext;
+    };
 };
 type ModuleFileTemplate = {
     type: 'file';
     fileName: string;
     build: TemplateCallback;
-    options: Required<TemplateOptions>;
+    options: Required<TemplateOptions> & {
+        context: TemplateContext;
+    };
 };
 type ModuleTemplate = ModuleCodeTemplate | ModuleFileTemplate;
 
@@ -37,6 +54,7 @@ type BlockValidationError = ValidationError & OptionValidationError;
 declare class CollectedBlockFile extends CollectedFile {
     folder: string;
     iconPath: string | null;
+    imagePath: string | null;
     iconContents: string | null;
     diffComponentPath: string | null;
     proxyComponentPath: string | null;
@@ -99,7 +117,7 @@ type ModuleOptions = {
     /**
      * An array of blökkli modules to use.
      */
-    modules?: BlokkliModule[];
+    modules?: BlokkliModule<any>[];
     /**
      * The pattern of source files to scan for blokkli components.
      */
@@ -144,6 +162,12 @@ type ModuleOptions = {
      * Using the paragraphs_blokkli integration this value should be set to "paragraph".
      */
     itemEntityType?: string;
+    /**
+     * The entity type of template entities.
+     *
+     * Using the paragraphs_blokkli integration this value should be set to "blokkli_paragraph_template".
+     */
+    templateEntityType?: string;
     /**
      * The name of the 'from library' block bundle.
      */
@@ -333,10 +357,61 @@ declare class ModuleHelper implements ValidationInterface {
     addComponent(name: string): void;
     addComposable(name: string): void;
     addAlias(name: string, path: string): void;
+    /**
+     * Add a path to Nitro's externals.inline for server-side usage.
+     * @see https://github.com/nuxt/nuxt/issues/28995
+     */
+    inlineForNitro(path: string): void;
     getMappedBlockBundle(bundle: string): string;
     validate(icons: IconCollector): boolean;
 }
 
+type ExtractedFeatureDefinition = {
+    id: string;
+    componentName: string;
+    componentPath: string;
+    definition: FeatureDefinitionBase;
+    definitionSource: string;
+};
+declare class CollectedFeatureFile extends CollectedFile {
+    private definition;
+    private composableName;
+    private enabled;
+    private objectLiteral;
+    getDefinition(): ExtractedFeatureDefinition | null;
+    handleChange(): Promise<boolean>;
+    isEnabled(): boolean;
+    /**
+     * Disable the feature.
+     */
+    disable(): void;
+}
+declare class FeatureCollector extends Collector<CollectedFeatureFile> {
+    protected needsFileContents: boolean;
+    private disabledFeatures;
+    private srcFromModule;
+    constructor(helper: ModuleHelper);
+    getEnabledFeatures(): ExtractedFeatureDefinition[];
+    init(): Promise<void>;
+    runHooks(): any;
+    createCollectedFile(filePath: string, fileContents?: string): CollectedFeatureFile;
+    applies(filePath: string): Promise<boolean>;
+    getDependencyTypes(): TemplateDependency[];
+    disableFeature(id: string): void;
+}
+
+type AlterHookContext<K extends string, T extends CollectedFile> = {
+    [P in K]: T[];
+};
+interface ModuleHooks {
+    'blokkli:alter-features': (ctx: AlterHookContext<'features', CollectedFeatureFile>) => void | Promise<void>;
+    'blokkli:alter-icons': (ctx: AlterHookContext<'icons', CollectedFile>) => void | Promise<void>;
+    'blokkli:alter-blocks': (ctx: AlterHookContext<'blocks', CollectedBlockFile>) => void | Promise<void>;
+}
+declare module '@nuxt/schema' {
+    interface NuxtHooks extends ModuleHooks {
+    }
+}
 type HandleWatchEventResult = {
     hasChanged: boolean;
 };
@@ -421,40 +496,6 @@ declare class IconCollector extends Collector {
     createCollectedFile(filePath: string, fileContents?: string): CollectedFile;
 }
 
-type ExtractedFeatureDefinition = {
-    id: string;
-    componentName: string;
-    componentPath: string;
-    definition: FeatureDefinitionBase;
-    definitionSource: string;
-};
-declare class CollectedFeatureFile extends CollectedFile {
-    private definition;
-    private composableName;
-    private enabled;
-    private objectLiteral;
-    getDefinition(): ExtractedFeatureDefinition | null;
-    handleChange(): Promise<boolean>;
-    isEnabled(): boolean;
-    /**
-     * Disable the feature.
-     */
-    disable(): void;
-}
-declare class FeatureCollector extends Collector<CollectedFeatureFile> {
-    protected needsFileContents: boolean;
-    private disabledFeatures;
-    private srcFromModule;
-    constructor(helper: ModuleHelper);
-    getEnabledFeatures(): ExtractedFeatureDefinition[];
-    init(): Promise<void>;
-    runHooks(): any;
-    createCollectedFile(filePath: string, fileContents?: string): CollectedFeatureFile;
-    applies(filePath: string): Promise<boolean>;
-    getDependencyTypes(): TemplateDependency[];
-    disableFeature(id: string): void;
-}
-
 declare class ThemeData {
     css: string;
     fullTheme: Record<string, any>;
@@ -462,6 +503,10 @@ declare class ThemeData {
     constructor(helper: ModuleHelper);
 }
 
+interface AdapterExtensionDefinition {
+    namespace: string;
+    path: string;
+}
 declare class ModuleContext {
     helper: ModuleHelper;
     icons: IconCollector;
@@ -470,11 +515,21 @@ declare class ModuleContext {
     theme: ThemeData;
     private templates;
     private templateContents;
+    private adapterExtensions;
+    collectors: Collector[];
     constructor(helper: ModuleHelper, icons: IconCollector, features: FeatureCollector, blocks: BlockCollector, theme: ThemeData);
+    registerAdapterExtension(namespace: string, path: string): void;
+    getAdapterExtensions(): AdapterExtensionDefinition[];
+    addCollector(collector: Collector): void;
     private getTemplateContents;
     private setTemplateContents;
     generateTemplates(dependencies?: TemplateDependency[]): Promise<void>;
     addTemplate(template: ModuleTemplate): void;
+    /**
+     * Add a template path to Nitro's externals.inline for server-side usage.
+     * @see https://github.com/nuxt/nuxt/issues/28995
+     */
+    private inlineForNitro;
     /**
      * Register a type template without adding to globalTypeFiles.
      *
@@ -498,5 +553,4 @@ type BlokkliModule<O extends object = object> = {
     init: BlokkliModuleInit<O>;
 };
 
-export { CollectedFile as C, CollectedFeatureFile as a, CollectedBlockFile as b };
-export type { BlokkliModule as B, ModuleOptions as M };
+export type { BlokkliModule as B, ModuleOptions as M, ModuleHooks as a };

package/dist/types.d.mts

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