@blokkli/editor 2.0.0-alpha.28 → 2.0.0-alpha.29

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

@@ -0,0 +1,5 @@
+import type { EntityContext } from '.';
+export type EditPermission = 'view' | 'edit' | 'review';
+export type BlokkliProviderEntityContext = EntityContext & {
+    language?: string;
+};

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

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

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

@@ -0,0 +1,462 @@
+import { WatchEvent, Nuxt } from 'nuxt/schema';
+import { ConsolaInstance } from 'consola';
+import { FragmentDefinitionInputBase, BlockDefinitionInputBase, BlockDefinitionOptionsInputBase } from '../../dist/global/types/definitions.js';
+import { ThemeName, Theme } from '../../dist/global/types/theme.js';
+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 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' | 'provider';
+type BlockValidationError = ValidationError & {
+    optionKey?: string;
+};
+declare class CollectedBlockFile extends CollectedFile {
+    folder: string;
+    iconPath: string | null;
+    iconContents: string | null;
+    diffComponentPath: string | null;
+    proxyComponentPath: string | null;
+    type: CollectedBlockType | null;
+    definition: FragmentDefinitionInputBase | BlockDefinitionInputBase | null;
+    definitionSource: string | null;
+    hasBlokkliField: boolean;
+    identifier: string;
+    chunkName: string;
+    variations: string[];
+    private objectLiteralString;
+    private validationCache;
+    private hasSiblingFile;
+    handleChange(helper: ModuleHelper): Promise<boolean>;
+    /**
+     * Validate the block definition and return any errors.
+     * Results are cached and invalidated when the file changes.
+     */
+    validate(): BlockValidationError[];
+}
+declare class BlockCollector extends Collector<CollectedBlockFile> {
+    private patterns;
+    constructor(helper: ModuleHelper);
+    init(): Promise<void>;
+    runHooks(): 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[];
+    validate(): boolean;
+}
+
+type GetBundlePropsTypeResult = {
+    typeName: string;
+    from: string;
+};
+type GetBundlePropsType = (name: string, definition: CollectedBlockFile) => GetBundlePropsTypeResult;
+type BuildRelativeImports = {
+    TYPES: string;
+    TYPES_DEFINITIONS: string;
+    RUNTIME_MATERIAL_ICONS: string;
+    CONSTANTS: string;
+    ADAPTER: string;
+    TYPES_THEME: string;
+    TYPES_BLOKK_OPTIONS: string;
+};
+type ModuleOptionsStorageDefaults = {
+    /**
+     * The default favorite block bundles.
+     */
+    blockFavorites?: string[];
+};
+/**
+ * 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?: BlockDefinitionOptionsInputBase;
+    /**
+     * 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;
+    /**
+     * The name of the 'from library' block bundle.
+     */
+    fromLibraryBlockBundle?: string;
+    /**
+     * The name of the 'blökkli' block bundle.
+     */
+    fragmentBlockBundle?: 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?: Record<string, {
+        disable?: boolean;
+        default?: any;
+    }>;
+    /**
+     * 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;
+};
+
+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;
+    logger: ConsolaInstance;
+    relativePaths: BuildRelativeImports;
+    paths: ModuleHelperPaths;
+    resolvers: ModuleHelperResolvers;
+    fileCache: FileCache;
+    readonly options: ModuleOptions;
+    readonly isDev: boolean;
+    readonly isModuleBuild: boolean;
+    constructor(nuxt: Nuxt, logger: ConsolaInstance, 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;
+    getMappedBlockBundle(bundle: string): string;
+}
+
+type HandleWatchEventResult = {
+    hasChanged: boolean;
+};
+type ValidationSeverity = 'error' | 'warning';
+type ValidationError = {
+    message: string;
+    severity?: ValidationSeverity;
+};
+declare class CollectedFile {
+    readonly filePath: string;
+    fileContents: string;
+    constructor(filePath: string, fileContents: string);
+    handleChange(_helper: ModuleHelper): Promise<boolean>;
+    /**
+     * Validate the collected file and return any errors.
+     * Override this method in subclasses to add validation logic.
+     */
+    validate(): ValidationError[];
+}
+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>;
+    /**
+     * Validate all collected files and log any errors/warnings to the console.
+     * @returns true if there are validation errors (not warnings), false otherwise.
+     */
+    validate(): boolean;
+}
+
+declare class IconCollector extends Collector {
+    protected needsFileContents: boolean;
+    private srcFromModule;
+    constructor(helper: ModuleHelper);
+    init(): Promise<void>;
+    runHooks(): any;
+    applies(filePath: string): Promise<boolean>;
+    getDependencyTypes(): TemplateDependency[];
+    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>;
+    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;
+    /**
+     * Register a type template without adding to globalTypeFiles.
+     *
+     * Uses addTemplate instead of addTypeTemplate to avoid Vue compiler-sfc
+     * issue where exported types from globalTypeFiles cannot be resolved.
+     * @see https://github.com/nuxt/nuxt/issues/33694
+     */
+    private addTypeTemplate;
+}
+
+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 { CollectedFile as C, CollectedFeatureFile as a, CollectedBlockFile as b };
+export type { BlokkliModule as B, ModuleOptions as M };

package/dist/types.d.mts

@@ -1 +1,3 @@
-export { type ModuleOptions, default } from './module.mjs'
+export { type ModuleOptions } from './shared/editor.DHqea16T.mjs'
+
+export { default } from './module.mjs'