@antv/infographic 0.1.3 → 0.2.0

package/lib/options/parser.js

@@ -12,19 +12,37 @@ function parseOptions(options) {
         ? document.querySelector(container) || document.createElement('div')
         : container;
     const templateOptions = template
-        ? (0, designs_1.getTemplate)(template) || {}
-        : {};
-    const { design: templateDesign, ...restTemplateOptions } = templateOptions;
-    return {
-        ...restTemplateOptions,
-        ...restOptions,
+        ? (0, designs_1.getTemplate)(template)
+        : undefined;
+    const mergedThemeConfig = (0, lodash_es_1.merge)({}, templateOptions?.themeConfig, themeConfig);
+    const resolvedThemeConfig = theme || themeConfig || templateOptions?.themeConfig
+        ? parseTheme(theme, mergedThemeConfig)
+        : undefined;
+    const parsed = {
         container: parsedContainer,
         padding: (0, utils_1.parsePadding)(padding),
-        template,
-        design: parseDesign({ ...templateDesign, ...design }, options),
-        theme,
-        themeConfig: parseTheme(theme, (0, lodash_es_1.merge)({ ...restTemplateOptions?.themeConfig }, themeConfig)),
     };
+    if (templateOptions) {
+        const { design: templateDesign, ...restTemplateOptions } = templateOptions;
+        Object.assign(parsed, restTemplateOptions);
+    }
+    Object.assign(parsed, restOptions);
+    if (template)
+        parsed.template = template;
+    if (templateOptions?.design || design) {
+        const parsedDesign = parseDesign({ ...templateOptions?.design, ...design }, resolvedThemeConfig
+            ? { ...options, themeConfig: resolvedThemeConfig }
+            : options);
+        if ((0, utils_1.isNonNullableParsedDesignsOptions)(parsedDesign)) {
+            parsed.design = parsedDesign;
+        }
+    }
+    if (theme)
+        parsed.theme = theme;
+    if (resolvedThemeConfig) {
+        parsed.themeConfig = resolvedThemeConfig;
+    }
+    return parsed;
 }
 function normalizeWithType(obj) {
     if (typeof obj === 'string')
@@ -47,11 +65,11 @@ function parseDesign(config, options) {
 }
 function parseDesignStructure(config) {
     if (!config)
-        throw new Error('Structure is required in design or template');
+        return null;
     const { type, ...userProps } = normalizeWithType(config);
     const structure = (0, designs_1.getStructure)(type);
     if (!structure)
-        throw new Error(`Structure ${type} not found`);
+        return null;
     const { component } = structure;
     return {
         ...structure,
@@ -72,11 +90,11 @@ function parseDesignTitle(config, options) {
 }
 function parseDesignItem(config, options) {
     if (!config)
-        throw new Error('Item is required in design or template');
+        return null;
     const { type, ...userProps } = normalizeWithType(config);
     const item = (0, designs_1.getItem)(type);
     if (!item)
-        throw new Error(`Item ${type} not found`);
+        return null;
     const { component, options: itemOptions } = item;
     return {
         ...item,

package/lib/renderer/composites/icon.js

@@ -23,7 +23,7 @@ function renderItemIcon(svg, node, value, options) {
 }
 function createIcon(svg, node, value, attrs) {
     // load async
-    (0, resource_1.loadResource)(svg, value);
+    (0, resource_1.loadResource)(svg, 'icon', value);
     return (0, utils_1.createIconElement)(value, {
         ...(0, utils_1.getAttributes)(node, [
             'id',

package/lib/renderer/composites/illus.js

@@ -11,7 +11,7 @@ function renderIllus(svg, node, value) {
         return null;
     const id = (0, resource_1.getResourceId)(config);
     const clipPathId = createClipPath(svg, node, id);
-    (0, resource_1.loadResource)(svg, config);
+    (0, resource_1.loadResource)(svg, 'illus', config);
     const { data, color } = config;
     return createIllusElement(id, {
         ...parseIllusBounds(node),

package/lib/resource/loader.d.ts

@@ -1,6 +1,6 @@
-import type { ResourceConfig } from './types';
+import type { ResourceConfig, ResourceScene } from './types';
 /**
  * load resource into svg defs
  * @returns resource ref id
  */
-export declare function loadResource(svg: SVGSVGElement | null, config: string | ResourceConfig): Promise<string | null>;
+export declare function loadResource(svg: SVGSVGElement | null, scene: ResourceScene, config: string | ResourceConfig): Promise<string | null>;

package/lib/resource/loader.js

@@ -5,19 +5,30 @@ const utils_1 = require("../utils");
 const loaders_1 = require("./loaders");
 const registry_1 = require("./registry");
 const utils_2 = require("./utils");
-async function getResource(config) {
+async function getResource(scene, config) {
     const cfg = (0, utils_2.parseResourceConfig)(config);
     if (!cfg)
         return null;
-    const { type, data } = cfg;
-    if (type === 'image') {
-        return await (0, loaders_1.loadImageBase64Resource)(data);
-    }
-    else if (type === 'svg') {
+    cfg.scene || (cfg.scene = scene);
+    const { source, data, format, encoding } = cfg;
+    if (source === 'inline') {
+        const isDataURI = data.startsWith('data:');
+        if (format === 'svg' && encoding === 'raw') {
+            return (0, loaders_1.loadSVGResource)(data);
+        }
+        if (format === 'svg' && isDataURI) {
+            return await (0, loaders_1.loadImageBase64Resource)(data);
+        }
+        if (isDataURI || format === 'image') {
+            return await (0, loaders_1.loadImageBase64Resource)(data);
+        }
         return (0, loaders_1.loadSVGResource)(data);
     }
-    else if (type === 'remote') {
-        return await (0, loaders_1.loadRemoteResource)(data);
+    else if (source === 'remote') {
+        return await (0, loaders_1.loadRemoteResource)(data, format);
+    }
+    else if (source === 'search') {
+        return await (0, loaders_1.loadSearchResource)(data, format);
     }
     else {
         const customLoader = (0, registry_1.getCustomResourceLoader)();
@@ -32,7 +43,7 @@ const RESOURCE_LOAD_MAP = new WeakMap();
  * load resource into svg defs
  * @returns resource ref id
  */
-async function loadResource(svg, config) {
+async function loadResource(svg, scene, config) {
     if (!svg)
         return null;
     const cfg = (0, utils_2.parseResourceConfig)(config);
@@ -41,7 +52,7 @@ async function loadResource(svg, config) {
     const id = (0, utils_2.getResourceId)(cfg);
     const resource = RESOURCE_MAP.has(id)
         ? RESOURCE_MAP.get(id) || null
-        : await getResource(cfg);
+        : await getResource(scene, cfg);
     if (!resource)
         return null;
     if (!RESOURCE_LOAD_MAP.has(svg))

package/lib/resource/loaders/index.d.ts

@@ -1,3 +1,4 @@
 export * from './image';
 export * from './remote';
+export * from './search';
 export * from './svg';

package/lib/resource/loaders/index.js

@@ -16,4 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./image"), exports);
 __exportStar(require("./remote"), exports);
+__exportStar(require("./search"), exports);
 __exportStar(require("./svg"), exports);

package/lib/resource/loaders/remote.d.ts

@@ -1 +1 @@
-export declare function loadRemoteResource(resource: string): Promise<SVGSymbolElement | null>;
+export declare function loadRemoteResource(resource: string, format?: string): Promise<SVGSymbolElement | null>;

package/lib/resource/loaders/remote.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadRemoteResource = loadRemoteResource;
+const utils_1 = require("../../utils");
 const image_1 = require("./image");
 const svg_1 = require("./svg");
 function isRemoteResource(resource) {
@@ -11,14 +12,22 @@ function isRemoteResource(resource) {
         return false;
     }
 }
-async function loadRemoteResource(resource) {
+function shouldParseAsSVG(contentType, format) {
+    const normalized = contentType.toLowerCase();
+    if (normalized.includes('image/svg'))
+        return true;
+    if (!contentType && format === 'svg')
+        return true;
+    return false;
+}
+async function loadRemoteResource(resource, format) {
     if (!resource || !isRemoteResource(resource))
         return null;
-    const response = await fetch(resource);
+    const response = await (0, utils_1.fetchWithCache)(resource);
     if (!response.ok)
         throw new Error('Failed to load resource');
     const contentType = response.headers.get('Content-Type') || '';
-    if (contentType.includes('image/svg+xml')) {
+    if (shouldParseAsSVG(contentType, format)) {
         const svgText = await response.text();
         return (0, svg_1.loadSVGResource)(svgText);
     }

package/lib/resource/loaders/search.d.ts

@@ -0,0 +1 @@
+export declare function loadSearchResource(query: string, format?: string): Promise<SVGSymbolElement | null>;

package/lib/resource/loaders/search.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSearchResource = loadSearchResource;
+const constants_1 = require("../../constants");
+const utils_1 = require("../../utils");
+const image_1 = require("./image");
+const remote_1 = require("./remote");
+const svg_1 = require("./svg");
+const queryIcon = async (query) => {
+    try {
+        const params = new URLSearchParams({ text: query, topK: '1' });
+        const url = `${constants_1.ICON_SERVICE_URL}?${params.toString()}`;
+        const response = await (0, utils_1.fetchWithCache)(url);
+        if (!response.ok)
+            return null;
+        const result = await response.json();
+        if (!result?.status || !Array.isArray(result.data?.data))
+            return null;
+        return result.data.data[0] || null;
+    }
+    catch (error) {
+        console.error(`Failed to query icon for "${query}":`, error);
+        return null;
+    }
+};
+function isDataURI(resource) {
+    return resource.startsWith('data:');
+}
+function looksLikeSVG(resource) {
+    const str = resource.trim();
+    return str.startsWith('<svg') || str.startsWith('<symbol');
+}
+async function loadSearchResource(query, format) {
+    if (!query)
+        return null;
+    const result = await queryIcon(query);
+    if (!result)
+        return null;
+    if (looksLikeSVG(result))
+        return (0, svg_1.loadSVGResource)(result);
+    if (isDataURI(result)) {
+        const mimeType = result.match(/^data:([^;]+)/)?.[1] || '';
+        const isBase64 = result.includes(';base64,');
+        if (mimeType === 'image/svg+xml' && !isBase64) {
+            const commaIndex = result.indexOf(',');
+            const svgText = commaIndex >= 0 ? result.slice(commaIndex + 1) : result;
+            return (0, svg_1.loadSVGResource)(svgText);
+        }
+        if (mimeType === 'image/svg+xml' && format === 'svg' && isBase64) {
+            return (0, image_1.loadImageBase64Resource)(result);
+        }
+        return (0, image_1.loadImageBase64Resource)(result);
+    }
+    return (0, remote_1.loadRemoteResource)(result, format);
+}

package/lib/resource/types/index.d.ts

@@ -1 +1,2 @@
 export type * from './resource';
+export type * from './scene';

package/lib/resource/types/resource.d.ts

@@ -1,6 +1,13 @@
+import { ResourceScene } from './scene';
+export type ResourceSource = 'inline' | 'remote' | 'search' | 'custom';
+export type ResourceFormat = 'svg' | 'image' | 'json' | 'binary' | string;
+export type ResourceEncoding = 'raw' | 'data-uri' | 'base64' | string;
 export interface ResourceConfig {
-    type: 'image' | 'svg' | 'remote' | 'custom';
+    source: ResourceSource;
+    format?: ResourceFormat;
+    encoding?: ResourceEncoding;
     data: string;
+    scene?: ResourceScene;
     [key: string]: any;
 }
 export type Resource = SVGSymbolElement;

package/lib/resource/types/scene.d.ts

@@ -0,0 +1 @@
+export type ResourceScene = 'icon' | 'illus';

package/lib/resource/utils/data-uri.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDataURI = parseDataURI;
 function parseDataURI(resource) {
     if (!resource.startsWith('data:'))
-        return { type: 'custom', data: resource };
+        return null;
     const commaIndex = resource.indexOf(',');
     if (commaIndex === -1)
         return null;
@@ -11,15 +11,24 @@ function parseDataURI(resource) {
     const data = resource.slice(commaIndex + 1);
     const parts = header.split(';');
     const mimeType = parts[0];
-    if (parts.includes('base64')) {
-        return { type: "image" /* DataURITypeEnum.Image */, data: resource };
+    const isBase64 = parts.includes('base64');
+    if (mimeType === 'image/svg+xml' && !isBase64) {
+        const decoded = data.startsWith('%3C') ? decodeURIComponent(data) : data;
+        return {
+            source: 'inline',
+            format: 'svg',
+            encoding: 'raw',
+            data: decoded,
+        };
+    }
+    if (mimeType.startsWith('image/')) {
+        const format = mimeType === 'image/svg+xml' ? 'svg' : 'image';
+        return {
+            source: 'inline',
+            format,
+            encoding: isBase64 ? 'base64' : 'data-uri',
+            data: resource,
+        };
     }
-    const typeMap = {
-        'text/url': "remote" /* DataURITypeEnum.Remote */,
-        'image/svg+xml': "svg" /* DataURITypeEnum.SVG */,
-    };
-    const type = typeMap[mimeType];
-    if (type)
-        return { type, data };
-    return { type: 'custom', data: resource };
+    return null;
 }

package/lib/resource/utils/parser.js

@@ -2,8 +2,99 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseResourceConfig = parseResourceConfig;
 const data_uri_1 = require("./data-uri");
+const KNOWN_FORMATS = new Set(['svg', 'png', 'jpg', 'jpeg', 'webp', 'gif']);
+function looksLikeSVG(resource) {
+    const str = resource.trim();
+    return str.startsWith('<svg') || str.startsWith('<symbol');
+}
+function inferFormatFromUrl(url) {
+    const lower = url.toLowerCase();
+    if (lower.endsWith('.svg') || lower.includes('.svg?'))
+        return 'svg';
+    if (lower.endsWith('.png') ||
+        lower.endsWith('.jpg') ||
+        lower.endsWith('.jpeg') ||
+        lower.endsWith('.webp') ||
+        lower.endsWith('.gif')) {
+        return 'image';
+    }
+    return undefined;
+}
+function parseRefResource(resource) {
+    if (!resource.startsWith('ref:'))
+        return null;
+    const rest = resource.slice(4);
+    const [source, ...restParts] = rest.split(':');
+    if (!source || restParts.length === 0)
+        return null;
+    let format;
+    if (restParts.length > 1 && KNOWN_FORMATS.has(restParts[0].toLowerCase())) {
+        format = restParts.shift()?.toLowerCase();
+    }
+    const payload = restParts.join(':');
+    if (!payload)
+        return null;
+    const normalizedSource = source === 'url' ? 'remote' : source;
+    if (normalizedSource === 'remote') {
+        return {
+            source: 'remote',
+            format: format || inferFormatFromUrl(payload) || undefined,
+            data: payload,
+        };
+    }
+    if (normalizedSource === 'search') {
+        return {
+            source: 'search',
+            format: format || 'svg',
+            data: payload,
+        };
+    }
+    if (normalizedSource === 'svg') {
+        return { source: 'inline', format: 'svg', data: payload, encoding: 'raw' };
+    }
+    return { source: 'custom', data: resource, format };
+}
 function parseResourceConfig(config) {
     if (!config)
         return null;
-    return typeof config === 'string' ? (0, data_uri_1.parseDataURI)(config) : config;
+    if (typeof config !== 'string') {
+        if (config.source)
+            return config;
+        const legacy = config;
+        if (legacy.type === 'image') {
+            return { source: 'inline', format: 'image', data: legacy.data };
+        }
+        if (legacy.type === 'svg') {
+            return {
+                source: 'inline',
+                format: 'svg',
+                encoding: 'raw',
+                data: legacy.data,
+            };
+        }
+        if (legacy.type === 'remote') {
+            return { source: 'remote', format: legacy.format, data: legacy.data };
+        }
+        if (legacy.type === 'search') {
+            return {
+                source: 'search',
+                format: legacy.format || 'svg',
+                data: legacy.data,
+            };
+        }
+        if (legacy.type === 'custom') {
+            return { source: 'custom', data: legacy.data };
+        }
+        return null;
+    }
+    const dataURIConfig = (0, data_uri_1.parseDataURI)(config);
+    if (dataURIConfig)
+        return dataURIConfig;
+    const refConfig = parseRefResource(config);
+    if (refConfig)
+        return refConfig;
+    if (looksLikeSVG(config)) {
+        return { source: 'inline', format: 'svg', encoding: 'raw', data: config };
+    }
+    return { source: 'custom', data: config };
 }

package/lib/resource/utils/ref.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getResourceId = getResourceId;
 exports.getResourceHref = getResourceHref;
 const utils_1 = require("../../utils");
-const data_uri_1 = require("./data-uri");
+const parser_1 = require("./parser");
 function getResourceId(config) {
-    const cfg = typeof config === 'string' ? (0, data_uri_1.parseDataURI)(config) : config;
+    const cfg = typeof config === 'string' ? (0, parser_1.parseResourceConfig)(config) : config;
     if (!cfg)
         return null;
     return 'rsc-' + (0, utils_1.getSimpleHash)(JSON.stringify(cfg));

package/lib/runtime/Infographic.d.ts

@@ -1,23 +1,27 @@
 import { type ExportOptions } from '../exporter';
-import { InfographicOptions } from '../options';
+import { InfographicOptions, ParsedInfographicOptions } from '../options';
 export declare class Infographic {
     rendered: boolean;
     private emitter;
     private node;
     private editor?;
+    private initialOptions;
     private options;
     private parsedOptions;
-    constructor(options: InfographicOptions);
-    getOptions(): InfographicOptions;
+    constructor(options: string | Partial<InfographicOptions>);
+    getOptions(): Partial<InfographicOptions>;
+    private setOptions;
     /**
      * Render the infographic into the container
      */
-    render(): void;
+    render(options?: string | Partial<InfographicOptions>): void;
+    update(options: string | Partial<InfographicOptions>): void;
+    private performRender;
     /**
      * Compose the SVG template
      */
-    compose(): SVGSVGElement;
-    getTypes(): string;
+    compose(parsedOptions: ParsedInfographicOptions): SVGSVGElement;
+    getTypes(): string | undefined;
     /**
      * Export the infographic to data URL
      * @param options Export option

package/lib/runtime/Infographic.js

@@ -6,12 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Infographic = void 0;
 const jsx_runtime_1 = require("@antv/infographic/jsx-runtime");
 const eventemitter3_1 = __importDefault(require("eventemitter3"));
-const lodash_es_1 = require("lodash-es");
 const editor_1 = require("../editor");
 const exporter_1 = require("../exporter");
 const jsx_1 = require("../jsx");
 const options_1 = require("../options");
 const renderer_1 = require("../renderer");
+const syntax_1 = require("../syntax");
 const utils_1 = require("../utils");
 const options_2 = require("./options");
 const utils_2 = require("./utils");
@@ -20,27 +20,60 @@ class Infographic {
         this.rendered = false;
         this.emitter = new eventemitter3_1.default();
         this.node = null;
-        this.options = {
-            ...options,
-            data: (0, lodash_es_1.cloneDeep)(options.data),
-            elements: (0, lodash_es_1.cloneDeep)(options.elements || []),
-        };
-        this.parsedOptions = (0, options_1.parseOptions)((0, utils_2.mergeOptions)(options_2.DEFAULT_OPTIONS, this.options));
+        this.initialOptions = {};
+        this.setOptions(options, 'replace', true);
     }
     getOptions() {
         return this.options;
     }
+    setOptions(options, mode = 'replace', isInitial = false) {
+        const { options: parsedOptions, errors, warnings, } = parseSyntaxOptions(options);
+        if (isInitial) {
+            this.initialOptions = (0, utils_2.cloneOptions)(parsedOptions);
+        }
+        const base = mode === 'replace'
+            ? (0, utils_2.mergeOptions)((0, utils_2.cloneOptions)(this.initialOptions || {}), parsedOptions)
+            : (0, utils_2.mergeOptions)(this.options || (0, utils_2.cloneOptions)(this.initialOptions || {}), parsedOptions);
+        this.options = base;
+        this.parsedOptions = (0, options_1.parseOptions)((0, utils_2.mergeOptions)(options_2.DEFAULT_OPTIONS, this.options));
+        if (warnings.length) {
+            this.emitter.emit('warning', warnings);
+        }
+        if (errors.length) {
+            this.emitter.emit('error', errors);
+        }
+    }
     /**
      * Render the infographic into the container
      */
-    render() {
+    render(options) {
+        if (options) {
+            this.setOptions(options, 'replace');
+        }
+        else if (!this.options && this.initialOptions) {
+            this.setOptions(this.initialOptions, 'replace');
+        }
+        this.performRender();
+    }
+    update(options) {
+        this.setOptions(options, 'merge');
+        this.performRender();
+    }
+    performRender() {
+        const parsedOptions = this.parsedOptions;
+        if (!(0, utils_2.isCompleteParsedInfographicOptions)(parsedOptions)) {
+            this.emitter.emit('error', new Error('Incomplete options'));
+            return;
+        }
         const { container } = this.parsedOptions;
-        const template = this.compose();
-        const renderer = new renderer_1.Renderer(this.parsedOptions, template);
+        const template = this.compose(parsedOptions);
+        const renderer = new renderer_1.Renderer(parsedOptions, template);
         this.node = renderer.render();
-        container.replaceChildren(this.node);
+        container?.replaceChildren(this.node);
+        this.editor?.destroy();
+        this.editor = undefined;
         if (this.options.editable) {
-            this.editor = new editor_1.Editor(this.emitter, this.node, this.parsedOptions);
+            this.editor = new editor_1.Editor(this.emitter, this.node, parsedOptions);
         }
         this.rendered = true;
         this.emitter.emit('rendered', { node: this.node, options: this.options });
@@ -48,14 +81,14 @@ class Infographic {
     /**
      * Compose the SVG template
      */
-    compose() {
-        const { design, data } = this.parsedOptions;
+    compose(parsedOptions) {
+        const { design, data } = parsedOptions;
         const { title, item, items, structure } = design;
         const { component: Structure, props: structureProps } = structure;
         const Title = title.component;
         const Item = item.component;
         const Items = items.map((it) => it.component);
-        const svg = (0, jsx_1.renderSVG)((0, jsx_runtime_1.jsx)(Structure, { data: data, Title: Title, Item: Item, Items: Items, options: this.parsedOptions, ...structureProps }));
+        const svg = (0, jsx_1.renderSVG)((0, jsx_runtime_1.jsx)(Structure, { data: data, Title: Title, Item: Item, Items: Items, options: parsedOptions, ...structureProps }));
         const template = (0, utils_1.parseSVG)(svg);
         if (!template) {
             throw new Error('Failed to parse SVG template');
@@ -63,7 +96,12 @@ class Infographic {
         return template;
     }
     getTypes() {
-        const design = this.parsedOptions.design;
+        const parsedOptions = this.parsedOptions;
+        if (!(0, utils_2.isCompleteParsedInfographicOptions)(parsedOptions)) {
+            this.emitter.emit('error', new Error('Incomplete options'));
+            return;
+        }
+        const design = parsedOptions.design;
         const structure = design.structure.composites || [];
         const items = design.items.map((it) => it.composites || []);
         return (0, utils_1.getTypes)({ structure, items });
@@ -99,3 +137,14 @@ class Infographic {
     }
 }
 exports.Infographic = Infographic;
+function parseSyntaxOptions(input) {
+    if (typeof input === 'string') {
+        const { options, errors, warnings } = (0, syntax_1.parseSyntax)(input);
+        return { options, errors, warnings };
+    }
+    return {
+        options: (0, utils_2.cloneOptions)(input),
+        errors: [],
+        warnings: [],
+    };
+}

package/lib/runtime/utils.d.ts

@@ -1,2 +1,4 @@
-import { InfographicOptions } from '../options/types';
-export declare function mergeOptions(object: Partial<InfographicOptions>, source: Partial<InfographicOptions>): InfographicOptions;
+import type { InfographicOptions, ParsedInfographicOptions } from '../options';
+export declare function mergeOptions(object: Partial<InfographicOptions>, source: Partial<InfographicOptions>): Partial<InfographicOptions>;
+export declare function cloneOptions<T extends Partial<InfographicOptions>>(options: T): T;
+export declare function isCompleteParsedInfographicOptions(options: Partial<ParsedInfographicOptions>): options is ParsedInfographicOptions;