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

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

@@ -11,20 +11,21 @@ import type { StateProvider } from '../helpers/stateProvider.js';
 import type { TextProvider } from '../helpers/textProvider.js';
 import type { eventBus } from './../helpers/eventBus.js';
 import type { BlockOptionDefinition } from './blokkOptions.js';
-import type { BlokkliAdapter, AdapterContext, MutationResponseLike } from './../adapter.js';
+import type { BlokkliAdapter, AdapterContext, MutationResponseLike } from './../adapter/index.js';
 import type { BroadcastProvider } from '#blokkli/helpers/broadcastProvider';
 import type { FeaturesProvider } from '#blokkli/helpers/featuresProvider';
 import type { BlokkliIcon } from '#blokkli-build/icons';
 import type { SettingsGroup, Viewport } from '#blokkli/constants';
-import type { BlockBundleWithNested, FieldListItemTyped, GlobalOptionsKey, ValidChunkNames, ValidFieldListTypes, ValidGlobalConfigKeys } from '#blokkli-build/generated-types';
-import type { globalOptions } from '#blokkli-build/definitions';
+import type { BlockBundleWithNested, FieldListItemTyped, GlobalOptionsKey, ValidChunkNames, ValidFieldListTypes, ValidGlobalConfigKeys, BundleProps } from '#blokkli-build/generated-types';
 import type { ThemeProvider } from '#blokkli/helpers/themeProvider';
+import type { GlobalOptionsType } from '#blokkli-build/definitions';
 import type { CommandsProvider } from '#blokkli/helpers/commandsProvider';
 import type { TourProvider } from '#blokkli/helpers/tourProvider';
 import type { DropAreaProvider } from '#blokkli/helpers/dropAreaProvider';
 import type { RGB } from './theme.js';
 import type { DebugProvider } from '#blokkli/helpers/debugProvider';
 import type getVideoId from 'get-video-id';
+import type { DefinitionProvider } from '../helpers/definitionProvider.js';
 export type MutateWithLoadingStateFunction = (promise: () => Promise<MutationResponseLike<any>> | undefined, errorMessage?: string, successMessage?: string) => Promise<boolean>;
 type GetType<T> = T extends {
     options: infer O;
@@ -43,10 +44,10 @@ export type BlockDefinitionOptionsInput = {
 type WithOptions<T extends BlockDefinitionOptionsInput> = {
     [K in keyof T]: GetType<T[K]>;
 };
-type GlobalOptionsType = typeof globalOptions;
 type GlobalOptionsKeyTypes<T extends ValidGlobalConfigKeys> = {
     [K in T[number]]: GetType<GlobalOptionsType[K]>;
 };
+export type BundleKey = keyof BundleProps;
 export type DefineBlokkliContext<T extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, G extends ValidGlobalConfigKeys | undefined = undefined> = {
     /**
      * The UUID of the item.
@@ -83,25 +84,29 @@ export type DefineBlokkliContext<T extends BlockDefinitionOptionsInput = BlockDe
      * options.
      */
     options: ComputedRef<(T extends BlockDefinitionOptionsInput ? WithOptions<T> : object) & (G extends ValidGlobalConfigKeys ? GlobalOptionsKeyTypes<G> : object)>;
+    /**
+     * The provider context.
+     */
+    provider: ComputedRef<BlokkliProviderEntityContext | null>;
 };
-type DetermineVisibleOptionsContext<T extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, G extends GlobalOptionsKey[] | undefined = undefined> = {
+type DetermineVisibleOptionsContext<T extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, G extends GlobalOptionsKey[] | undefined = undefined, B extends BundleKey | string = string> = {
     options: (T extends BlockDefinitionOptionsInput ? WithOptions<T> : object) & (G extends ValidGlobalConfigKeys ? GlobalOptionsKeyTypes<G> : object);
     parentType: BlockBundleWithNested | undefined;
     fieldListType: ValidFieldListTypes;
-    props: Record<string, any>;
+    props: B extends BundleKey ? BundleProps[B] : Record<string, any>;
     entity: AdapterContext;
 };
 type ExtractGlobalOptions<G extends GlobalOptionsKey[]> = G[number] extends GlobalOptionsKey ? G[number] : never;
 type CombineKeysAndGlobalOptions<T extends BlockDefinitionOptionsInput, G extends GlobalOptionsKey[] | undefined> = keyof T | ExtractGlobalOptions<NonNullable<G>>;
 export type BlokkliDefinitionAddBehaviour = 'no-form' | 'form' | `editable:${string}`;
-export type BlokkliDefinitionInputEditor<Options extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, GlobalOptions extends GlobalOptionsKey[] | undefined = undefined> = {
+export type BlokkliDefinitionInputEditor<Options extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, GlobalOptions extends GlobalOptionsKey[] | undefined = undefined, Bundle extends BundleKey | string = string> = {
     /**
      * Determine which options should be visible in the editor based on the
      * given context.
      *
      * If a method is defined, it is called whenever any of the options change.
      */
-    determineVisibleOptions?: (ctx: DetermineVisibleOptionsContext<Options, GlobalOptions>) => Array<CombineKeysAndGlobalOptions<Options, GlobalOptions>>;
+    determineVisibleOptions?: (ctx: DetermineVisibleOptionsContext<Options, GlobalOptions, Bundle>) => Array<CombineKeysAndGlobalOptions<Options, GlobalOptions>>;
     /**
      * Disable editing for blocks that don't have any editable fields.
      *
@@ -244,11 +249,11 @@ export type BlockDefinitionRenderForFieldListType = {
     fieldListType: ValidFieldListTypes;
 };
 export type BlockDefinitionRenderFor = BlockDefinitionRenderForParent | BlockDefinitionRenderForFieldList | BlockDefinitionRenderForFieldListType;
-export type BlockDefinitionInput<Options extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, GlobalOptions extends GlobalOptionsKey[] | undefined = []> = {
+export type BlockDefinitionInput<Options extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, GlobalOptions extends GlobalOptionsKey[] | undefined = [], Bundle extends BundleKey | string = string> = {
     /**
      * The bundle ID of the block, e.g. "text" or "section_title".
      */
-    bundle: string;
+    bundle: Bundle;
     /**
      * Define the name of a block bundle that supports nested blocks.
      * If a bundle is defined, then this component will be rendered if the
@@ -277,19 +282,20 @@ export type BlockDefinitionInput<Options extends BlockDefinitionOptionsInput = B
     /**
      * Settings for the behaviour in the editor.
      */
-    editor?: BlokkliDefinitionInputEditor<Options, GlobalOptions>;
+    editor?: BlokkliDefinitionInputEditor<Options, GlobalOptions, Bundle>;
 };
 export type RuntimeBlockDefinitionInput = {
     bundle: string;
 };
-export type InjectedBlokkliItem = ComputedRef<{
+export type InjectedBlokkliItem = {
     index: ComputedRef<number>;
     uuid: string;
     options?: Record<string, string> | undefined;
     isEditing: boolean;
     parentType?: BlockBundleWithNested;
     fieldListType?: ValidFieldListTypes;
-}>;
+    fragmentName?: string;
+};
 export type FieldListItem = {
     uuid: string;
     bundle: string;
@@ -929,6 +935,7 @@ export type ItemEditContext = {
     eventBus: Eventbus;
     mutatedOptions: MutatedOptions;
     dom?: DomProvider;
+    definitions: DefinitionProvider;
 };
 export interface BlokkliApp {
     /**
@@ -947,6 +954,7 @@ export interface BlokkliApp {
     keyboard: KeyboardProvider;
     ui: UiProvider;
     animation: AnimationProvider;
+    definitions: DefinitionProvider;
     state: StateProvider;
     context: ComputedRef<AdapterContext>;
     $t: TextProvider;
@@ -1012,7 +1020,7 @@ export type FeatureDefinitionSettingSlider = {
 export type FeatureDefinitionSettingMethod = {
     type: 'method';
     label: string;
-    method: () => void;
+    method: (app: BlokkliApp) => void;
     group?: SettingsGroup;
     viewports?: Viewport[];
 };
@@ -1161,5 +1169,17 @@ export interface LibraryItemProps {
     label?: string;
     uuid?: string;
 }
+export type PublishOptions = {
+    canPublish: boolean;
+    isRevisionable: boolean;
+    hasRevisionLogMessage: boolean;
+    lastChanged?: string | null;
+};
+export type GetEditStatesItem = {
+    hostEntityType: string;
+    hostEntityUuid: string;
+    entity: EditEntity;
+    currentUserIsOwner: boolean;
+};
 declare const _default: {};
 export default _default;

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'