@builder.io/sdk-qwik 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/sdk-qwik",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Builder.io Qwik SDK",
   "type": "module",
   "main": "./lib/index.qwik.cjs",

package/types/components/render-block/render-block.d.ts

@@ -7,6 +7,7 @@ export declare type RenderBlockProps = {
 export declare const component: (props: any, state: any) => import("../../context/types.js").RegisteredComponent | null | undefined;
 export declare const tag: (props: any, state: any) => string;
 export declare const useBlock: (props: any, state: any) => any;
+export declare const proxyState: (props: any, state: any) => any;
 export declare const actions: (props: any, state: any) => {
     [index: string]: (event: Event) => any;
 };
@@ -24,6 +25,7 @@ export declare const renderComponentProps: (props: any, state: any) => {
         state: any;
         content: any;
         context: any;
+        setState: any;
         registeredComponents: any;
         inheritedStyles: Partial<CSSStyleDeclaration>;
     };
@@ -35,6 +37,7 @@ export declare const childrenContext: (props: any, state: any) => {
     state: any;
     content: any;
     context: any;
+    setState: any;
     registeredComponents: any;
     inheritedStyles: Partial<CSSStyleDeclaration>;
 };

package/types/components/render-block/render-component.d.ts

@@ -1,9 +1,16 @@
 import type { BuilderBlock } from "../../types/builder-block.js";
 import type { BuilderContextInterface } from "../../context/types.js";
 import type { Breakpoints } from "../../types/builder-content.js";
+declare type ComponentOptions = {
+    [index: string]: any;
+    customBreakpoints?: Breakpoints;
+    attributes?: {
+        [index: string]: any;
+    };
+};
 export interface RenderComponentProps {
     componentRef: any;
-    componentOptions: any;
+    componentOptions: ComponentOptions;
     blockChildren: BuilderBlock[];
     context: BuilderContextInterface;
     customBreakpoints?: Breakpoints;

package/types/components/render-content/components/render-styles.d.ts

@@ -1,19 +1,8 @@
-interface CustomFont {
-    family?: string;
-    kind?: string;
-    fileUrl?: string;
-    files?: {
-        [key: string]: string;
-    };
-}
+import type { CustomFont } from "./render-styles.helpers";
 interface Props {
     cssCode?: string;
     customFonts?: CustomFont[];
+    contentId?: string;
 }
-export declare const getCssFromFont: (props: any, state: any, font: CustomFont) => string;
-export declare const getFontCss: (props: any, state: any, { customFonts, }: {
-    customFonts?: CustomFont[] | undefined;
-}) => string;
-export declare const injectedStyles: (props: any, state: any) => string;
 export declare const RenderContentStyles: import("@builder.io/qwik").Component<Props>;
 export default RenderContentStyles;

package/types/components/render-content/components/render-styles.helpers.d.ts

@@ -0,0 +1,15 @@
+export interface CustomFont {
+    family?: string;
+    kind?: string;
+    fileUrl?: string;
+    files?: {
+        [key: string]: string;
+    };
+}
+export declare const getFontCss: ({ customFonts }: {
+    customFonts?: CustomFont[] | undefined;
+}) => string;
+export declare const getCss: ({ cssCode, contentId, }: {
+    cssCode?: string | undefined;
+    contentId?: string | undefined;
+}) => string;

package/types/components/render-content/render-content.d.ts

@@ -1,21 +1,9 @@
-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;
-    locale?: string;
-    includeRefs?: boolean;
-};
-export declare const useContent: (props: any, state: any, elementRef: any) => any;
-export declare const contentState: (props: any, state: any, elementRef: any) => any;
+import type { BuilderRenderState } from "../../context/types.js";
+import type { Breakpoints, BuilderContent } from "../../types/builder-content.js";
+import type { RenderContentProps } from "./render-content.types.js";
+export declare const mergeNewContent: (props: any, state: any, elementRef: any, newContent: BuilderContent) => void;
+export declare const setBreakpoints: (props: any, state: any, elementRef: any, breakpoints: Breakpoints) => void;
+export declare const setContextState: (props: any, state: any, elementRef: any, newState: BuilderRenderState) => void;
 export declare const processMessage: (props: any, state: any, elementRef: any, event: MessageEvent) => void;
 export declare const evaluateJsCode: (props: any, state: any, elementRef: any) => void;
 export declare const onClick: (props: any, state: any, elementRef: any, event: any) => void;

package/types/components/render-content/render-content.helpers.d.ts

@@ -0,0 +1,7 @@
+import type { BuilderContent } from '../../types/builder-content';
+import type { Nullable } from '../../types/typescript';
+import type { RenderContentProps } from './render-content.types';
+export declare const getContextStateInitialValue: ({ content, data, locale, }: Pick<RenderContentProps, 'content' | 'data' | 'locale'>) => {
+    [x: string]: unknown;
+};
+export declare const getContentInitialValue: ({ content, data, }: Pick<RenderContentProps, 'content' | 'data'>) => Nullable<BuilderContent>;

package/types/components/render-content/render-content.types.d.ts

@@ -0,0 +1,27 @@
+import type { BuilderRenderContext, RegisteredComponent, BuilderRenderState } from '../../context/types';
+import type { BuilderContent } from '../../types/builder-content';
+import type { Nullable } from '../../types/typescript';
+export declare type RenderContentProps = {
+    content?: Nullable<BuilderContent>;
+    model?: string;
+    data?: {
+        [key: string]: any;
+    };
+    context?: BuilderRenderContext;
+    apiKey: string;
+    customComponents?: RegisteredComponent[];
+    canTrack?: boolean;
+    locale?: string;
+    includeRefs?: boolean;
+};
+export interface BuilderComponentStateChange {
+    state: BuilderRenderState;
+    ref: {
+        name?: string;
+        props?: {
+            builderBlock?: {
+                id?: string;
+            };
+        };
+    };
+}

package/types/context/types.d.ts

@@ -11,6 +11,7 @@ export interface BuilderContextInterface {
     content: Nullable<BuilderContent>;
     context: BuilderRenderContext;
     state: BuilderRenderState;
+    setState?: (state: BuilderRenderState) => void;
     apiKey: string | null;
     registeredComponents: RegisteredComponents;
     inheritedStyles: Record<string, unknown>;

package/types/index-helpers/blocks-exports.d.ts

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

package/types/types/builder-content.d.ts

@@ -1,6 +1,6 @@
 import type { BuilderBlock } from './builder-block.js';
+import type { Input } from './components.js';
 import type { Nullable } from './typescript.js';
-declare type Input = any;
 export interface Breakpoints {
     small: number;
     medium: number;
@@ -44,4 +44,3 @@ export interface BuilderContent extends BuilderContentVariation {
     testVariationId?: string;
     testVariationName?: string;
 }
-export {};

package/types/types/input.d.ts

@@ -0,0 +1,117 @@
+export interface Input {
+    /** This is the name of the component prop this input represents */
+    name: string;
+    /** A friendlier name to show in the UI if the component prop name is not ideal for end users */
+    friendlyName?: string;
+    /** @hidden @deprecated */
+    description?: string;
+    /** A default value to use */
+    defaultValue?: any;
+    /**
+     * The type of input to use, such as 'text'
+     *
+     * See all available inputs [here](https://www.builder.io/c/docs/custom-react-components#input-types)
+     * and you can create your own custom input types and associated editor UIs with [plugins](https://www.builder.io/c/docs/extending/plugins)
+     */
+    type: string;
+    /** Is this input mandatory or not */
+    required?: boolean;
+    /** @hidden */
+    autoFocus?: boolean;
+    subFields?: Input[];
+    /**
+     * Additional text to render in the UI to give guidance on how to use this
+     *
+     * @example
+     * ```js
+     * helperText: 'Be sure to use a proper URL, starting with "https://"'
+     * 111
+     */
+    helperText?: string;
+    /** @hidden */
+    allowedFileTypes?: string[];
+    /** @hidden */
+    imageHeight?: number;
+    /** @hidden */
+    imageWidth?: number;
+    /** @hidden */
+    mediaHeight?: number;
+    /** @hidden */
+    mediaWidth?: number;
+    /** @hidden */
+    hideFromUI?: boolean;
+    /** @hidden */
+    modelId?: string;
+    /**
+     * Number field type validation maximum accepted input
+     */
+    max?: number;
+    /**
+     * Number field type validation minimum accepted input
+     */
+    min?: number;
+    /**
+     * Number field type step size when using arrows
+     */
+    step?: number;
+    /**
+     * Set this to `true` to show the editor for this input when
+     * children of this component are selected. This is useful for things
+     * like Tabs, such that users may not always select the Tabs component
+     * directly but will still be looking for how to add additional tabs
+     */
+    broadcast?: boolean;
+    /**
+     * Set this to `true` to show the editor for this input when
+     * group locked parents of this component are selected. This is useful
+     * to bubble up important inputs for locked groups, like text and images
+     */
+    bubble?: boolean;
+    /**
+     * Set this to `true` if you want this component to be translatable
+     */
+    localized?: boolean;
+    /** @hidden */
+    options?: {
+        [key: string]: any;
+    };
+    /**
+     * For "text" input type, specifying an enum will show a dropdown of options instead
+     */
+    enum?: string[] | {
+        label: string;
+        value: any;
+        helperText?: string;
+    }[];
+    /** Regex field validation for all string types (text, longText, html, url, etc) */
+    regex?: {
+        /** pattern to test, like "^\/[a-z]$" */
+        pattern: string;
+        /** flags for the RegExp constructor, e.g. "gi"  */
+        options?: string;
+        /**
+         * Friendly message to display to end-users if the regex fails, e.g.
+         * "You must use a relative url starting with '/...' "
+         */
+        message: string;
+    };
+    /**
+     * Set this to `true` to put this under the "show more" section of
+     * the options editor. Useful for things that are more advanced
+     * or more rarely used and don't need to be too prominent
+     */
+    advanced?: boolean;
+    /** @hidden */
+    /** @hidden */
+    code?: boolean;
+    /** @hidden */
+    richText?: boolean;
+    /** @hidden */
+    showIf?: ((options: Map<string, any>) => boolean) | string;
+    /** @hidden */
+    copyOnAdd?: boolean;
+    /**
+     * Use optionally with inputs of type `reference`. Restricts the content entry picker to a specific model by name.
+     */
+    model?: string;
+}