@blokkli/editor 1.4.0-alpha.1 → 2.0.0-alpha.10

package/dist/shared/editor.gz_ac6uT.d.mts

@@ -0,0 +1,431 @@
+import { WatchEvent, Nuxt } from 'nuxt/schema';
+import { FeatureDefinition, AdapterMethods, FragmentDefinitionInput, BlockDefinitionInput, BlockDefinitionOptionsInput } from '../../dist/runtime/types/index.js';
+import { ModuleOptionsSettings } from '#blokkli-build/module-types';
+import { ThemeName, Theme } from '../../dist/runtime/types/theme.js';
+import { Resolver } from '@nuxt/kit';
+
+type TemplateCallback = (context: ModuleContext) => string | Promise<string>;
+type TemplateDependency = 'icons' | 'features' | 'block-content' | 'block-path' | 'block-global-options';
+type TemplateOptions = {
+    dependencies?: TemplateDependency[];
+    write?: boolean;
+};
+type ModuleCodeTemplate = {
+    type: 'code';
+    name: string;
+    buildCode: TemplateCallback;
+    buildTypes: TemplateCallback;
+    options: Required<TemplateOptions>;
+};
+type ModuleFileTemplate = {
+    type: 'file';
+    fileName: string;
+    build: TemplateCallback;
+    options: Required<TemplateOptions>;
+};
+type ModuleTemplate = ModuleCodeTemplate | ModuleFileTemplate;
+
+type CollectedBlockType = 'main' | 'context' | 'fragment';
+declare class CollectedBlockFile extends CollectedFile {
+    folder: string;
+    iconPath: string | null;
+    iconContents: string | null;
+    diffComponentPath: string | null;
+    proxyComponentPath: string | null;
+    type: CollectedBlockType | null;
+    definition: ExtractedFragmentDefinitionInput | ExtractedBlockDefinitionInput | null;
+    definitionSource: string | null;
+    hasBlokkliField: boolean;
+    identifier: string;
+    chunkName: string;
+    variations: string[];
+    private objectLiteralString;
+    private hasSiblingFile;
+    handleChange(helper: ModuleHelper): Promise<boolean>;
+}
+declare class BlockCollector extends Collector<CollectedBlockFile> {
+    private patterns;
+    constructor(helper: ModuleHelper);
+    init(): Promise<void>;
+    runHooks(): Promise<any>;
+    createCollectedFile(filePath: string, fileContents?: string): CollectedBlockFile;
+    private findBlockForFolderFile;
+    protected handleAdd(filePath: string): Promise<boolean>;
+    protected handleUnlink(filePath: string): Promise<boolean>;
+    protected handleChange(filePath: string): Promise<boolean>;
+    applies(filePath: string): Promise<boolean>;
+    getDependencyTypes(): TemplateDependency[];
+}
+
+type ExtractedFeatureDefinition = {
+    id: string;
+    componentName: string;
+    componentPath: string;
+    definition: FeatureDefinition<AdapterMethods[]>;
+    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(): Promise<any>;
+    createCollectedFile(filePath: string, fileContents?: string): CollectedFeatureFile;
+    applies(filePath: string): Promise<boolean>;
+    getDependencyTypes(): TemplateDependency[];
+    disableFeature(id: string): void;
+}
+
+type ExtractedBlockDefinitionInput = BlockDefinitionInput;
+type ExtractedFragmentDefinitionInput = FragmentDefinitionInput;
+type GetBundlePropsTypeResult = {
+    typeName: string;
+    from: string;
+};
+type GetBundlePropsType = (name: string, definition: CollectedBlockFile) => GetBundlePropsTypeResult;
+type BuildRelativeImports = {
+    TYPES: string;
+    CONSTANTS: string;
+    ADAPTER: string;
+    TYPES_THEME: string;
+    TYPES_BLOKK_OPTIONS: string;
+};
+type ModuleOptionsStorageDefaults = {
+    /**
+     * The default favorite block bundles.
+     */
+    blockFavorites?: string[];
+};
+type AlterHookContext<K extends string, T extends CollectedFile> = {
+    [P in K]: T[];
+};
+/**
+ * Options for the module.
+ */
+type ModuleOptions = {
+    /**
+     * An array of blökkli modules to use.
+     */
+    modules?: BlokkliModule[];
+    /**
+     * The pattern of source files to scan for blokkli components.
+     */
+    pattern?: string[];
+    /**
+     * Define reusable options that can be used in blokkli item components by
+     * referencing the option name.
+     */
+    globalOptions?: BlockDefinitionOptionsInput;
+    /**
+     * Custom path where the blökkli edit adapter can be found.
+     *
+     * Must be an absolute path and the file must exist when the module
+     * is initialised.
+     */
+    editAdapterPath?: string;
+    /**
+     * Define available chunk groups.
+     *
+     * The idea of this feature is to split rarely used components into separate
+     * chunks, so that they are not imported on each page.
+     *
+     * This value should only be set if the component is actually used rarely.
+     * Having too many chunks has the opposite effect, as rendering a page
+     * requires multiple requests.
+     *
+     * If left empty, all components are bundled in a default chunk, which should
+     * contain components that are used for most pages.
+     */
+    chunkNames?: string[];
+    /**
+     * Valid field list types.
+     *
+     * If one or more values are defined, they can be passed to the BlokkliField
+     * component as a prop. The value is made available to all blokkli items inside
+     * this field.
+     */
+    fieldListTypes?: string[];
+    /**
+     * The entity type of blokkli items.
+     *
+     * Using the paragraphs_blokkli integration this value should be set to "paragraph".
+     */
+    itemEntityType?: string;
+    /**
+     * Provide overrides for the translations.
+     */
+    translations?: Record<string, Record<string, string>>;
+    /**
+     * The default/fallback language for the editor.
+     */
+    defaultLanguage?: string;
+    /**
+     * Force the editor to always be in the default language.
+     *
+     * The default behaviour is that the editor is rendered in the same language
+     * as the page entity. Setting this value to true will always render the
+     * editor in the default language.
+     */
+    forceDefaultLanguage?: boolean;
+    /**
+     * Add custom features by defining either a pattern or path to a feature component.
+     */
+    featureImports?: string[];
+    /**
+     * Theme colors for the editor.
+     *
+     * Accent colors are used for selections, highlights, buttons.
+     * Mono colors are used for the UI elements in the editor.
+     */
+    theme?: ThemeName | Partial<Theme>;
+    /**
+     * Enable the theme editor feature.
+     */
+    enableThemeEditor?: boolean;
+    /**
+     * blokkli generates a JSON file that contains all the defined block
+     * options, keyed by block bundle. By default the file is output to
+     * .nuxt/blokkli/options-schema.json, but the path can be overriden here.
+     *
+     * The path can use aliases like ~ or @ and must also contain the file
+     * name including the extension.
+     */
+    schemaOptionsPath?: string;
+    /**
+     * Override the feature settings.
+     */
+    settingsOverride?: ModuleOptionsSettings;
+    /**
+     * The default storage values for non-settings values.
+     *
+     * These values are not visible in the settings dialog, but are still
+     * "settable" by the user through interactions. This option allows you to
+     * define default values for these settings, like default favorite block
+     * bundles.
+     */
+    storageDefaults?: ModuleOptionsStorageDefaults;
+    /**
+     * Method that is called for each block bundle component to generate the
+     * prop types.
+     *
+     * These types are used if you access a block item with the generated
+     * FieldListItemTyped type, for example through:
+     * const { rootBlocks } = defineBlokkli().
+     *
+     * or using <BlokkliField v-slot="{ items }">.
+     *
+     * The method receives the name of the bundle and the extracted block
+     * definition as the second argument.
+     * The return value should be an object with these properties:
+     *
+     * - typeName: The name of the type
+     * - from: Where the type can be imported from
+     *
+     * For example, if the method returns this object:
+     * ```typescript
+     * {
+     *   typeName: 'ParagraphTextWithImageFragment',
+     *   from: '#graphql-operations'
+     * }
+     * ```
+     *
+     * Then the module will generate this TypeScript code:
+     *
+     * ```typescript
+     * import type { ParagraphTextWithImageFragment } from '#graphql-operations'
+     * ```
+     *
+     * And assign the imported type as the type for the `props` property for this bundle.
+     *
+     * Then, for example in a block component:
+     *
+     * ```typescript
+     * const { siblings, index } = defineBlokkli()
+     *
+     * const previousBlock = computed(() => siblings.value[index.value - 1])
+     *
+     * const previousTitle = computed(() => {
+     *   // The previous block in the list is a title.
+     *   if (previousBlock.value?.bundle === 'title') {
+     *     // The type of the props are now typed correctly.
+     *     const title = previousBlock.value.props.title
+     *   }
+     * })
+     * ```
+     */
+    getBundlePropsType?: GetBundlePropsType;
+};
+interface ModuleHooks {
+    /**
+     * Alter features.
+     */
+    'blokkli:alter-features': (ctx: AlterHookContext<'features', CollectedFeatureFile>) => void | Promise<void>;
+    /**
+     * Alter icons.
+     */
+    'blokkli:alter-icons': (ctx: AlterHookContext<'icons', CollectedFile>) => void | Promise<void>;
+    /**
+     * Alter blocks.
+     */
+    'blokkli:alter-blocks': (ctx: AlterHookContext<'blocks', CollectedBlockFile>) => void | Promise<void>;
+}
+
+declare class FileCache {
+    private cache;
+    private existingFiles;
+    /**
+     * Read a file from disk.
+     */
+    read(filePath: string): Promise<string>;
+    /**
+     * Delete a file.
+     */
+    delete(filePath: string): void;
+    /**
+     * Check if a file exists.
+     */
+    fileExists(filePath: string): boolean;
+    /**
+     * Handles the builder watch event.
+     */
+    handleWatchEvent(event: WatchEvent, filePath: string): Promise<void>;
+}
+
+type ModuleHelperResolvers = {
+    /**
+     * Resolver for files relative to the module src.
+     */
+    module: Resolver;
+    /**
+     * Resolver for files relative to the blökkli build directory.
+     */
+    build: Resolver;
+    /**
+     * Resolver for files relative to the Nuxt app source directory.
+     */
+    src: Resolver;
+    /**
+     * Resolver for the app directory.
+     */
+    app: Resolver;
+};
+type ModuleHelperPaths = {
+    blokkliBuildDir: string;
+    srcDir: string;
+    editAdapter: string;
+};
+declare class ModuleHelper {
+    nuxt: Nuxt;
+    relativePaths: BuildRelativeImports;
+    paths: ModuleHelperPaths;
+    resolvers: ModuleHelperResolvers;
+    fileCache: FileCache;
+    readonly options: ModuleOptions;
+    readonly isDev: boolean;
+    readonly isModuleBuild: boolean;
+    constructor(nuxt: Nuxt, moduleUrl: string, providedOptions: ModuleOptions);
+    /**
+     * Transform the path relative to the module's build directory.
+     *
+     * @param path - The absolute path.
+     *
+     * @returns The path relative to the module's build directory.
+     */
+    toModuleBuildRelative(path: string): string;
+    private findEditAdapterPath;
+    getChunkNames(): string[];
+    addComponent(name: string): void;
+    addComposable(name: string): void;
+    addAlias(name: string, path: string): void;
+}
+
+type HandleWatchEventResult = {
+    hasChanged: boolean;
+};
+declare class CollectedFile {
+    readonly filePath: string;
+    fileContents: string;
+    constructor(filePath: string, fileContents: string);
+    handleChange(_helper: ModuleHelper): Promise<boolean>;
+}
+declare abstract class Collector<T extends CollectedFile = CollectedFile> {
+    protected helper: ModuleHelper;
+    files: Map<string, T>;
+    protected needsFileContents: boolean;
+    constructor(helper: ModuleHelper);
+    abstract init(): Promise<any>;
+    abstract runHooks(): Promise<any>;
+    abstract applies(filePath: string): Promise<boolean>;
+    abstract createCollectedFile(filePath: string, fileContents?: string): T;
+    abstract getDependencyTypes(): TemplateDependency[];
+    addFile(filePath: string): Promise<void>;
+    protected handleAdd(filePath: string): Promise<boolean>;
+    protected handleChange(filePath: string): Promise<boolean>;
+    protected handleUnlink(filePath: string): Promise<boolean> | boolean;
+    private handleAddDir;
+    private handleUnlinkDir;
+    handleWatchEvent(event: WatchEvent, filePath: string): Promise<HandleWatchEventResult>;
+}
+
+declare class IconCollector extends Collector {
+    protected needsFileContents: boolean;
+    private srcFromModule;
+    constructor(helper: ModuleHelper);
+    init(): Promise<void>;
+    runHooks(): Promise<any>;
+    applies(filePath: string): Promise<boolean>;
+    getDependencyTypes(): TemplateDependency[];
+    createCollectedFile(filePath: string, fileContents?: string): CollectedFile;
+}
+
+declare class ThemeData {
+    css: string;
+    fullTheme: Record<string, any>;
+    hasCustomTheme: boolean;
+    constructor(helper: ModuleHelper);
+}
+
+declare class ModuleContext {
+    helper: ModuleHelper;
+    icons: IconCollector;
+    features: FeatureCollector;
+    blocks: BlockCollector;
+    theme: ThemeData;
+    private templates;
+    private templateContents;
+    constructor(helper: ModuleHelper, icons: IconCollector, features: FeatureCollector, blocks: BlockCollector, theme: ThemeData);
+    private getTemplateContents;
+    private setTemplateContents;
+    generateTemplates(dependencies?: TemplateDependency[]): Promise<void>;
+    addTemplate(template: ModuleTemplate): void;
+}
+
+type Blokkli = {
+    helper: ModuleHelper;
+    context: ModuleContext;
+};
+type BlokkliModuleInit<O extends object> = {
+    alterOptions?: (options: ModuleOptions) => void;
+    setup: (app: Blokkli, options: O) => Promise<void> | void;
+};
+type BlokkliModule<O extends object = object> = {
+    options?: O;
+    init: BlokkliModuleInit<O>;
+};
+
+export type { BlokkliModule as B, ModuleHooks as M, ModuleOptions as a };

package/dist/types.d.mts

@@ -1 +1 @@
-export { type ModuleOptions, default } from './module.js'
+export { type ModuleOptions, default } from './module.mjs'

package/package.json

@@ -1,35 +1,43 @@
 {
   "name": "@blokkli/editor",
-  "version": "1.4.0-alpha.1",
+  "version": "2.0.0-alpha.10",
   "description": "Interactive page building experience for Nuxt",
   "repository": "blokkli/editor",
   "type": "module",
-  "private": false,
   "exports": {
     ".": {
-      "import": "./dist/module.mjs",
-      "require": "./dist/module.cjs"
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./drupal": "./dist/modules/drupal/index.mjs"
+  },
+  "main": "./dist/module.mjs",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ],
+      "drupal": [
+        "./dist/modules/drupal/index.d.mts"
+      ]
     }
   },
-  "main": "./dist/module.cjs",
-  "types": "./dist/types.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "prepack": "nuxt-module-build build && find dist/ -type f -name '*.*' | grep '.spec.' | xargs rm -f",
+    "prepack": "rm -rf dist && nuxt-module-build build && find dist/ -type f -name '*.*' | grep '.spec.' | xargs rm -f",
     "dev": "nuxi dev playground --host",
     "typecheck": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "dev:minimal": "nuxi dev playground-minimal --host",
-    "dev:content": "nuxi dev playground-content --host",
     "styles:build": "postcss ./css/index.css -o ./src/runtime/css/output.css",
     "styles:watch": "postcss ./css/index.css -o ./src/runtime/css/output.css --watch",
     "dev:build": "npm run dev:prepare && nuxi generate playground",
     "dev:start": "npx serve playground/.output/public",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "dev:prepare": "PLAYGROUND_MODULE_BUILD=true nuxt-module-build build --stub && PLAYGROUND_MODULE_BUILD=true nuxt-module-build prepare && nuxi prepare playground",
     "release": "npm run lint && npm run prepack && changelogen --release",
     "texts": "node ./scripts/texts/index.cjs",
-    "generate-types": "node ./scripts/generateTypes/index.cjs",
+    "drupal-types": "node ./scripts/drupal/index.cjs",
     "lint": "eslint ./src",
     "lint:fix": "eslint ./src --fix",
     "test": "vitest run",
@@ -48,7 +56,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@nuxt/kit": "^3.13.1",
+    "@types/micromatch": "^4.0.9",
     "artboard-deluxe": "^0.1.0",
     "estree-walker-ts": "^1.0.1",
     "fzf": "^0.5.2",
@@ -61,11 +69,11 @@
   "devDependencies": {
     "@ckeditor/ckeditor5-build-classic": "^43.1.0",
     "@ckeditor/ckeditor5-vue": "^7.0.0",
-    "@nuxt/content": "^2.13.2",
     "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^0.5.7",
-    "@nuxt/module-builder": "^0.8.4",
-    "@nuxt/schema": "^3.13.1",
+    "@nuxt/eslint-config": "^1.3.0",
+    "@nuxt/kit": "^3.17.2",
+    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/schema": "^3.17.2",
     "@nuxt/test-utils": "^3.14.2",
     "@nuxtjs/tailwindcss": "^6.12.1",
     "@tailwindcss/forms": "^0.5.9",
@@ -76,13 +84,14 @@
     "@vue/test-utils": "^2.4.6",
     "changelogen": "^0.5.5",
     "cypress": "^13.14.2",
-    "eslint": "^8.57.0",
-    "eslint-plugin-sonarjs": "^2.0.2",
-    "eslint-plugin-tailwindcss": "^3.17.4",
+    "eslint": "^9.24.0",
+    "eslint-plugin-sonarjs": "^3.0.2",
+    "eslint-plugin-tailwindcss": "^3.18.0",
     "gettext-parser": "^8.0.0",
     "happy-dom": "^15.7.4",
-    "nuxt": "^3.15.4",
-    "nuxt-svg-icon-sprite": "^1.0.2",
+    "nuxt": "^3.17.2",
+    "nuxt-graphql-middleware": "^5.0.0-alpha.18",
+    "nuxt-svg-icon-sprite": "^2.0.0-alpha.1",
     "openai": "^4.59.0",
     "playwright-core": "^1.47.0",
     "postcss": "^8.4.45",
@@ -97,10 +106,6 @@
     "tailwindcss": "^3.4.11",
     "vite-plugin-glsl": "^1.3.0",
     "vitepress": "^1.3.4",
-    "vitest": "^2.0.5",
-    "vue-tsc": "^2.1.6"
-  },
-  "overrides": {
-    "@parcel/watcher": "~2.1.0"
+    "vitest": "^2.0.5"
   }
 }

package/dist/module.cjs

@@ -1,5 +0,0 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
-}
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)