@builder.io/sdk-vue 0.0.2-2 → 0.0.2

package/packages/_vue3/dist/src/components/render-content/render-content.vue.d.ts

@@ -0,0 +1,139 @@
+import type { BuilderRenderContext, RegisteredComponent } from "../../context/types.js";
+import type { BuilderContent } from "../../types/builder-content.js";
+import type { Nullable } from "../../types/typescript.js";
+export declare type RenderContentProps = {
+    content?: Nullable<BuilderContent>;
+    model?: string;
+    data?: {
+        [key: string]: any;
+    };
+    context?: BuilderRenderContext;
+    apiKey: string;
+    customComponents?: RegisteredComponent[];
+    canTrack?: boolean;
+};
+import { markMutable } from "../../functions/mark-mutable.js";
+declare const _sfc_main: {
+    name: string;
+    components: {
+        "render-content-styles": {
+            name: string;
+            components: {
+                "render-inlined-styles": {
+                    name: string;
+                    props: string[];
+                    data: () => {
+                        TARGET: string;
+                    };
+                    computed: {
+                        injectedStyleScript(): any;
+                        tagName(): string;
+                    };
+                };
+            };
+            props: string[];
+            computed: {
+                injectedStyles(): any;
+            };
+            methods: {
+                getCssFromFont(font: any): string;
+                getFontCss({ customFonts }: {
+                    customFonts: any;
+                }): any;
+            };
+        };
+        "render-blocks": {
+            name: string;
+            components: {
+                "render-block": any;
+                "block-styles": {
+                    name: string;
+                    components: {
+                        "render-inlined-styles": {
+                            name: string;
+                            props: string[];
+                            data: () => {
+                                TARGET: string;
+                            };
+                            computed: {
+                                injectedStyleScript(): any;
+                                tagName(): string;
+                            };
+                        };
+                    };
+                    props: string[];
+                    data: () => {
+                        TARGET: string;
+                    };
+                    computed: {
+                        useBlock(): any;
+                        css(): any;
+                    };
+                };
+            };
+            props: string[];
+            inject: {
+                builderContext: string;
+            };
+            computed: {
+                className(): any;
+            };
+            methods: {
+                onClick(): void;
+                onMouseEnter(): void;
+                _classStringToObject(str: any): {};
+            };
+        };
+    };
+    props: string[];
+    data: () => {
+        forceReRenderCount: number;
+        overrideContent: null;
+        update: number;
+        overrideState: {};
+        markMutable: typeof markMutable;
+    };
+    provide(): {
+        BuilderContext: {
+            readonly content: any;
+            readonly state: any;
+            readonly context: any;
+            readonly apiKey: any;
+            readonly registeredComponents: any;
+        };
+    };
+    mounted(): void;
+    watch: {
+        onUpdateHook0(): void;
+        onUpdateHook1(): void;
+        onUpdateHook2(): void;
+    };
+    unmounted(): void;
+    computed: {
+        useContent(): any;
+        canTrackToUse(): any;
+        contentState(): any;
+        contextContext(): any;
+        allRegisteredComponents(): any;
+        httpReqsData(): {};
+        shouldRenderContentStyles(): any;
+        onUpdateHook0(): any;
+        onUpdateHook1(): any;
+        onUpdateHook2(): {
+            0: () => any;
+        };
+    };
+    methods: {
+        processMessage(event: any): void;
+        evaluateJsCode(): void;
+        onClick(_event: any): void;
+        evalExpression(expression: any): any;
+        handleRequest({ url, key }: {
+            url: any;
+            key: any;
+        }): void;
+        runHttpRequests(): void;
+        emitStateUpdate(): void;
+    };
+};
+export default _sfc_main;

package/packages/_vue3/dist/src/components/render-inlined-styles.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _sfc_main: {
+    name: string;
+    props: string[];
+    data: () => {
+        TARGET: string;
+    };
+    computed: {
+        injectedStyleScript(): any;
+        tagName(): string;
+    };
+};
+export default _sfc_main;

package/packages/_vue3/dist/src/constants/builder-registered-components.d.ts

@@ -0,0 +1,6 @@
+import type { RegisteredComponent } from '../context/types.js';
+/**
+ * Returns a list of all registered components.
+ * NOTE: This needs to be a function to work around ESM circular dependencies.
+ */
+export declare const getDefaultRegisteredComponents: () => RegisteredComponent[];

package/packages/_vue3/dist/src/constants/device-sizes.d.ts

@@ -0,0 +1,2 @@
+export declare type SizeName = 'large' | 'medium' | 'small';
+export declare const getMaxWidthQueryForSize: (size: SizeName) => string;

package/packages/_vue3/dist/src/constants/target.d.ts

@@ -0,0 +1,2 @@
+/** This file should be overriden for each framework. Ideally this would be implemented in Mitosis.  */
+export declare const TARGET = "vue3";

package/packages/_vue3/dist/src/context/builder.context.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/packages/_vue3/dist/src/context/types.d.ts

@@ -0,0 +1,16 @@
+import type { BuilderContent } from '../types/builder-content.js';
+import type { ComponentInfo } from '../types/components.js';
+import type { Dictionary, Nullable } from '../types/typescript.js';
+export declare type RegisteredComponent = ComponentInfo & {
+    component: any;
+};
+export declare type RegisteredComponents = Dictionary<RegisteredComponent>;
+export declare type BuilderRenderState = Record<string, unknown>;
+export declare type BuilderRenderContext = Record<string, unknown>;
+export interface BuilderContextInterface {
+    content: Nullable<BuilderContent>;
+    context: BuilderRenderContext;
+    state: BuilderRenderState;
+    apiKey: string | null;
+    registeredComponents: RegisteredComponents;
+}

package/packages/_vue3/dist/src/functions/camel-to-kebab-case.d.ts

@@ -0,0 +1 @@
+export declare const camelToKebabCase: (string: string) => string;

package/packages/_vue3/dist/src/functions/evaluate.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderContextInterface } from '../context/types.js';
+export declare function evaluate({ code, context, state, event, }: {
+    code: string;
+    event?: Event;
+} & Pick<BuilderContextInterface, 'state' | 'context'>): any;

package/packages/_vue3/dist/src/functions/event-handler-name.d.ts

@@ -0,0 +1 @@
+export declare const getEventHandlerName: (key: string) => string;

package/packages/_vue3/dist/src/functions/get-block-actions-handler.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function crateEventHandler(value: string, options: {
+    block: BuilderBlock;
+} & Pick<BuilderContextInterface, 'state' | 'context'>): (event: Event) => any;

package/packages/_vue3/dist/src/functions/get-block-actions.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+declare type Actions = {
+    [index: string]: (event: Event) => any;
+};
+export declare function getBlockActions(options: {
+    block: BuilderBlock;
+} & Pick<BuilderContextInterface, 'state' | 'context'>): Actions;
+export {};

package/packages/_vue3/dist/src/functions/get-block-component-options.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getBlockComponentOptions(block: BuilderBlock): any;

package/packages/_vue3/dist/src/functions/get-block-properties.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getBlockProperties(block: BuilderBlock): {
+    'builder-id': string | undefined;
+    class: {};
+};

package/packages/_vue3/dist/src/functions/get-block-styles.d.ts

@@ -0,0 +1 @@
+export declare function getBlockStyles(): {};

package/packages/_vue3/dist/src/functions/get-block-tag.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare type TagName = string;
+export declare function getBlockTag(block: BuilderBlock): TagName;

package/packages/_vue3/dist/src/functions/get-builder-search-params/index.d.ts

@@ -0,0 +1,6 @@
+declare type QueryObject = Record<string, string>;
+export declare const convertSearchParamsToQueryObject: (searchParams: URLSearchParams) => QueryObject;
+export declare const getBuilderSearchParams: (_options: QueryObject | URLSearchParams | undefined) => QueryObject;
+export declare const getBuilderSearchParamsFromWindow: () => QueryObject;
+export declare const normalizeSearchParams: (searchParams: QueryObject | URLSearchParams) => QueryObject;
+export {};

package/packages/_vue3/dist/src/functions/get-content/ab-testing.d.ts

@@ -0,0 +1,5 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+import type { CanTrack } from '../../types/can-track.js';
+export declare const handleABTesting: ({ item, canTrack, }: {
+    item: BuilderContent;
+} & CanTrack) => Promise<void>;

package/packages/_vue3/dist/src/functions/get-content/index.d.ts

@@ -0,0 +1,9 @@
+import type { BuilderContent } from '../../types/builder-content.js';
+export declare type GetContentOptions = import('./types.js').GetContentOptions;
+export declare function getContent(options: GetContentOptions): Promise<BuilderContent | null>;
+export declare const generateContentUrl: (options: GetContentOptions) => URL;
+interface ContentResponse {
+    results: BuilderContent[];
+}
+export declare function getAllContent(options: GetContentOptions): Promise<ContentResponse>;
+export {};

package/packages/_vue3/dist/src/functions/get-content/types.d.ts

@@ -0,0 +1,31 @@
+export interface GetContentOptions {
+    /** The model to get content for */
+    model: string;
+    /** Your public API key */
+    apiKey: string;
+    /** Number of items to fetch. Default is 1 */
+    limit?: number;
+    /** User attributes to target on, such as { urlPath: '/foo', device: 'mobile', ...etc } */
+    userAttributes?: (Record<string, string> & {
+        urlPath?: string;
+    }) | null;
+    /** Custom query */
+    query?: Record<string, any>;
+    /**
+     * Any other API options.
+     * Accepts both a key/value object or a `URLSearchParams` instance
+     * */
+    options?: Record<string, any> | URLSearchParams;
+    /**
+     * If set to `true`, it will lazy load symbols/references.
+     * If set to `false`, it will render the entire content tree eagerly.
+     */
+    noTraverse?: boolean;
+    /**
+     * If set to `false`, it will not use cookies to target content. Therefore, A/B Testing will be disabled and
+     * only the default variation will be returned to every user.
+     *
+     * Defaults to `true`.
+     */
+    canTrack?: boolean;
+}

package/packages/_vue3/dist/src/functions/get-fetch.d.ts

@@ -0,0 +1 @@
+export declare function getFetch(): Promise<typeof global.fetch>;

package/packages/_vue3/dist/src/functions/get-global-this.d.ts

@@ -0,0 +1 @@
+export declare function getGlobalThis(): any;

package/packages/_vue3/dist/src/functions/get-processed-block.d.ts

@@ -0,0 +1,10 @@
+import type { BuilderContextInterface } from '../context/types.js';
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function getProcessedBlock({ block, context, shouldEvaluateBindings, state, }: {
+    block: BuilderBlock;
+    /**
+     * In some cases, we want to avoid evaluating bindings and only want framework-specific block transformation. It is
+     * also sometimes too early to consider bindings, e.g. when we might be looking at a repeated block.
+     */
+    shouldEvaluateBindings: boolean;
+} & Pick<BuilderContextInterface, 'state' | 'context'>): BuilderBlock;

package/packages/_vue3/dist/src/functions/is-browser.d.ts

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/packages/_vue3/dist/src/functions/is-editing.d.ts

@@ -0,0 +1 @@
+export declare function isEditing(): boolean;

package/packages/_vue3/dist/src/functions/is-iframe.d.ts

@@ -0,0 +1 @@
+export declare function isIframe(): boolean;

package/packages/_vue3/dist/src/functions/is-previewing.d.ts

@@ -0,0 +1 @@
+export declare function isPreviewing(): boolean;

package/packages/_vue3/dist/src/functions/mark-mutable.d.ts

@@ -0,0 +1,2 @@
+export declare function markMutable<T = any>(value: T): T;
+export declare function markPropsMutable<T = any>(props: T): T;

package/packages/_vue3/dist/src/functions/register-component.d.ts

@@ -0,0 +1,14 @@
+import type { RegisteredComponent } from '../context/types.js';
+import type { ComponentInfo } from '../types/components.js';
+/**
+ * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+ */
+export declare const components: RegisteredComponent[];
+/**
+ * @deprecated.  Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.
+ */
+export declare function registerComponent(component: any, info: ComponentInfo): void;
+export declare const createRegisterComponentMessage: ({ component: _, ...info }: RegisteredComponent) => {
+    type: string;
+    data: ComponentInfo;
+};

package/packages/_vue3/dist/src/functions/register.d.ts

@@ -0,0 +1,16 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+import type { DeepPartial } from '../types/deep-partial.js';
+export interface InsertMenuItem {
+    name: string;
+    icon?: string;
+    item: DeepPartial<BuilderBlock>;
+}
+export interface InsertMenuConfig {
+    name: string;
+    priority?: number;
+    persist?: boolean;
+    advanced?: boolean;
+    items: InsertMenuItem[];
+}
+export declare function register(type: 'insertMenu', info: InsertMenuConfig): void;
+export declare function register(type: string, info: any): void;

package/packages/_vue3/dist/src/functions/set-editor-settings.d.ts

@@ -0,0 +1,4 @@
+export declare type Settings = {
+    customInsertMenu?: boolean;
+};
+export declare function setEditorSettings(newSettings: Settings): void;

package/packages/_vue3/dist/src/functions/set.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Minimal implementation of lodash's _.set
+ * https://lodash.com/docs/4.17.15#set
+ *
+ * See ./set.test.ts for usage examples
+ */
+export declare const set: (obj: any, _path: string | string[], value: any) => any;

package/packages/_vue3/dist/src/functions/track.d.ts

@@ -0,0 +1,21 @@
+import type { CanTrack } from '../types/can-track.js';
+interface Event {
+    type: 'click' | 'impression';
+    data: {
+        contentId?: string;
+        ownerId: string;
+        metadata?: string;
+        sessionId: string | undefined;
+        visitorId: string | undefined;
+        [index: string]: any;
+    };
+}
+declare type EventProperties = {
+    type: Event['type'];
+    orgId: Event['data']['ownerId'];
+    contentId: Event['data']['contentId'];
+    [index: string]: any;
+};
+export declare type EventProps = EventProperties & CanTrack;
+export declare function track(eventProps: EventProps): Promise<void | Response>;
+export {};

package/packages/_vue3/dist/src/functions/transform-block.d.ts

@@ -0,0 +1,2 @@
+import type { BuilderBlock } from '../types/builder-block.js';
+export declare function transformBlock(block: BuilderBlock): BuilderBlock;

package/packages/_vue3/dist/src/helpers/ab-tests.d.ts

@@ -0,0 +1,8 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getContentVariationCookie: ({ contentId, canTrack, }: {
+    contentId: string;
+} & CanTrack) => Promise<string | undefined>;
+export declare const setContentVariationCookie: ({ contentId, canTrack, value, }: {
+    contentId: string;
+    value: string;
+} & CanTrack) => Promise<undefined>;

package/packages/_vue3/dist/src/helpers/cookie.d.ts

@@ -0,0 +1,15 @@
+import type { CanTrack } from '../types/can-track.js';
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
+export declare const getCookie: ({ name, canTrack, }: {
+    name: string;
+} & CanTrack) => Promise<string | undefined>;
+/**
+ * NOTE: This function is `async` because its react-native override is async. Do not remove the `async` keyword!
+ */
+export declare const setCookie: ({ name, value, expires, canTrack, }: {
+    name: string;
+    value: string;
+    expires?: Date | undefined;
+} & CanTrack) => Promise<undefined>;

package/packages/_vue3/dist/src/helpers/css.d.ts

@@ -0,0 +1 @@
+export declare const convertStyleMaptoCSS: (style: Partial<CSSStyleDeclaration>) => string;

package/packages/_vue3/dist/src/helpers/flatten.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert deep object to a flat object with dots
+ *
+ * { foo: { bar: 'baz' }} -> { 'foo.bar': 'baz' }
+ */
+export declare function flatten<T extends Record<string, any>>(object: T, path?: string | null, separator?: string): T;

package/packages/_vue3/dist/src/helpers/localStorage.d.ts

@@ -0,0 +1,8 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getLocalStorageItem: ({ key, canTrack, }: {
+    key: string;
+} & CanTrack) => string | null | undefined;
+export declare const setLocalStorageItem: ({ key, canTrack, value, }: {
+    key: string;
+    value: string;
+} & CanTrack) => void;

package/packages/_vue3/dist/src/helpers/nullable.d.ts

@@ -0,0 +1,2 @@
+export declare type Nullable<T> = T | null | undefined;
+export declare const checkIsDefined: <T>(maybeT: Nullable<T>) => maybeT is T;

package/packages/_vue3/dist/src/helpers/sessionId.d.ts

@@ -0,0 +1,6 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getSessionId: ({ canTrack }: CanTrack) => Promise<string | undefined>;
+export declare const createSessionId: () => string;
+export declare const setSessionId: ({ id, canTrack, }: {
+    id: string;
+} & CanTrack) => Promise<undefined>;

package/packages/_vue3/dist/src/helpers/url.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Only gets one level up from hostname
+ * wwww.example.com -> example.com
+ * www.example.co.uk -> example.co.uk
+ */
+export declare const getTopLevelDomain: (host: string) => string;

package/packages/_vue3/dist/src/helpers/uuid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @credit https://stackoverflow.com/a/2117523
+ */
+export declare function uuidv4(): string;
+/**
+ * Slightly cleaner and smaller UUIDs
+ */
+export declare function uuid(): string;

package/packages/_vue3/dist/src/helpers/visitorId.d.ts

@@ -0,0 +1,6 @@
+import type { CanTrack } from '../types/can-track.js';
+export declare const getVisitorId: ({ canTrack }: CanTrack) => string | undefined;
+export declare const createVisitorId: () => string;
+export declare const setVisitorId: ({ id, canTrack, }: {
+    id: string;
+} & CanTrack) => void;

package/packages/_vue3/dist/src/index-helpers/blocks-exports.d.ts

@@ -0,0 +1,10 @@
+export { default as Columns } from '../blocks/columns/columns.vue';
+export { default as Image } from '../blocks/image/image.vue';
+export { default as Text } from '../blocks/text/text.vue';
+export { default as Video } from '../blocks/video/video.vue';
+export { default as Symbol } from '../blocks/symbol/symbol.vue';
+export { default as Button } from '../blocks/button/button.vue';
+export { default as Section } from '../blocks/section/section.vue';
+export { default as Fragment } from '../blocks/fragment/fragment.vue';
+export { default as RenderContent } from '../components/render-content/render-content.vue';
+export { default as RenderBlocks } from '../components/render-blocks.vue';

package/packages/_vue3/dist/src/index-helpers/top-of-file.d.ts

@@ -0,0 +1 @@
+export default undefined;

package/packages/_vue3/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from './index-helpers/blocks-exports.js';
+export * from './functions/is-editing.js';
+export * from './functions/is-previewing.js';
+export * from './functions/register-component.js';
+export * from './functions/register.js';
+export * from './functions/set-editor-settings.js';
+export * from './functions/get-content/index.js';
+export * from './functions/get-builder-search-params/index.js';

package/packages/_vue3/dist/src/scripts/init-editing.d.ts

@@ -0,0 +1,2 @@
+export declare const registerInsertMenu: () => void;
+export declare const setupBrowserForEditing: () => void;

package/packages/_vue3/dist/src/types/builder-block.d.ts

@@ -0,0 +1,57 @@
+declare type JSONValue = string | number | boolean | JSONObject | JSONArray;
+interface JSONObject {
+    [x: string]: JSONValue;
+}
+interface JSONArray extends Array<JSONValue> {
+}
+/** @todo typedoc this */
+export interface BuilderBlock {
+    '@type': '@builder.io/sdk:Element';
+    '@version'?: number;
+    id?: string;
+    tagName?: string;
+    layerName?: string;
+    groupLocked?: boolean;
+    layerLocked?: boolean;
+    /** @todo make alias for properties.class */
+    class?: string;
+    children?: BuilderBlock[];
+    responsiveStyles?: {
+        large?: Partial<CSSStyleDeclaration>;
+        medium?: Partial<CSSStyleDeclaration>;
+        small?: Partial<CSSStyleDeclaration>;
+        /** @deprecated */
+        xsmall?: Partial<CSSStyleDeclaration>;
+    };
+    component?: {
+        name: string;
+        options?: any;
+        tag?: string;
+    };
+    bindings?: {
+        [key: string]: string;
+    };
+    meta?: {
+        [key: string]: JSONValue;
+    };
+    actions?: {
+        [key: string]: string;
+    };
+    properties?: {
+        [key: string]: string;
+    };
+    code?: {
+        bindings?: {
+            [key: string]: string;
+        };
+        actions?: {
+            [key: string]: string;
+        };
+    };
+    repeat?: {
+        collection: string;
+        itemName?: string;
+    } | null;
+    animations?: any[];
+}
+export {};

package/packages/_vue3/dist/src/types/builder-content.d.ts

@@ -0,0 +1,38 @@
+import type { BuilderBlock } from './builder-block.js';
+declare type Input = any;
+export interface BuilderContentVariation {
+    data?: {
+        title?: string;
+        blocks?: BuilderBlock[];
+        inputs?: Input[];
+        state?: {
+            [key: string]: any;
+        };
+        jsCode?: string;
+        tsCode?: string;
+        httpRequests?: {
+            [key: string]: string;
+        };
+        [key: string]: any;
+    };
+    name?: string;
+    testRatio?: number;
+    id?: string;
+}
+export interface BuilderContent extends BuilderContentVariation {
+    '@version'?: number;
+    id?: string;
+    name?: string;
+    published?: 'published' | 'draft' | 'archived';
+    modelId?: string;
+    priority?: number;
+    lastUpdated?: number;
+    startDate?: number;
+    endDate?: number;
+    variations?: {
+        [id: string]: BuilderContentVariation | undefined;
+    };
+    testVariationId?: string;
+    testVariationName?: string;
+}
+export {};

package/packages/_vue3/dist/src/types/can-track.d.ts

@@ -0,0 +1,3 @@
+export declare type CanTrack = {
+    canTrack: boolean;
+};