@malloydata/render 0.0.289 → 0.0.291

package/dist/data_tree/fields/base.d.ts

@@ -0,0 +1,65 @@
+import * as Malloy from '@malloydata/malloy-interfaces';
+import type { Tag } from '@malloydata/malloy-tag';
+import type { Field, NestField, RecordField, RecordOrRepeatedRecordField, BasicAtomicField, TimeField, RootField } from '.';
+import { ArrayField, BooleanField, DateField, JSONField, NumberField, RepeatedRecordField, SQLNativeField, StringField, TimestampField } from '.';
+import type { FieldRegistry } from '../types';
+import type { RenderPluginInstance } from '../plugins';
+export declare abstract class FieldBase {
+    readonly field: Malloy.DimensionInfo;
+    readonly parent: NestField | undefined;
+    readonly tag: Tag;
+    readonly path: string[];
+    protected readonly metadataTag: Tag;
+    readonly renderAs: string;
+    readonly valueSet: Set<string | number | boolean>;
+    private _pluginData;
+    protected registry?: FieldRegistry;
+    registerPluginData<T>(pluginType: string, data: T): void;
+    getPluginData<T>(pluginType: string): T | undefined;
+    getAllFieldInstances(): Field[];
+    getPlugins(): RenderPluginInstance[];
+    constructor(field: Malloy.DimensionInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    isRoot(): boolean;
+    root(): RootField;
+    get drillPath(): string[];
+    get sourceName(): string;
+    get sourceArguments(): Malloy.ParameterValue[] | undefined;
+    get name(): string;
+    fieldAt(path: string[] | string): Field;
+    getParentRecord(levelsUp: number): RecordField;
+    get key(): string;
+    fieldAtPath(path: string[]): Field;
+    registerNullValue(): void;
+    get drillFilters(): string[];
+    getStableDrillFilter(filter: Tag): Malloy.Filter | undefined;
+    get stableDrillFilters(): Malloy.Filter[] | undefined;
+    get referenceId(): string | undefined;
+    private escapeIdentifier;
+    private identifierCode;
+    drillExpression(): string;
+    wasDimension(): boolean;
+    wasCalculation(): boolean;
+    isHidden(): boolean;
+    get minNumber(): number | undefined;
+    get maxNumber(): number | undefined;
+    get maxString(): string | undefined;
+    asField(): Field;
+    isArray(): this is ArrayField;
+    isRepeatedRecord(): this is RepeatedRecordField;
+    isRecord(): this is RecordField;
+    isNumber(): this is NumberField;
+    isBoolean(): this is BooleanField;
+    isString(): this is StringField;
+    isRecordOrRepeatedRecord(): this is RecordOrRepeatedRecordField;
+    isDate(): this is DateField;
+    isTimestamp(): this is TimestampField;
+    isTime(): this is TimeField;
+    isSQLNative(): this is SQLNativeField;
+    isJSON(): this is JSONField;
+    isBasic(): this is BasicAtomicField;
+    isNest(): this is NestField;
+    getLocationInParent(): any;
+    isLastChild(): any;
+    isFirstChild(): any;
+    pathTo(childField: Field): string;
+}

package/dist/data_tree/fields/index.d.ts

@@ -0,0 +1,17 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import { BooleanField, DateField, JSONField, NumberField, SQLNativeField, StringField, TimestampField } from './atomic';
+import { ArrayField, RecordField, RepeatedRecordField } from './nest';
+import type { FieldRegistry } from '../types';
+export { ArrayField, RecordField, RepeatedRecordField, RootField } from './nest';
+export { BooleanField, DateField, JSONField, NumberField, SQLNativeField, StringField, TimestampField, } from './atomic';
+export type Field = ArrayField | RepeatedRecordField | RecordField | NumberField | DateField | JSONField | StringField | TimestampField | BooleanField | SQLNativeField;
+export type NestField = RepeatedRecordField | RecordField | ArrayField;
+export type RecordOrRepeatedRecordField = RepeatedRecordField | RecordField;
+export type BasicAtomicField = NumberField | DateField | JSONField | StringField | TimestampField | BooleanField | SQLNativeField;
+export type TimeField = DateField | TimestampField;
+export declare const Field: {
+    from(field: Malloy.DimensionInfo, parent: NestField | undefined, registry?: FieldRegistry): Field;
+    isNestField(field: Field): field is NestField;
+    pathFromString(path: string): any;
+    pathToString(path: string): string;
+};

package/dist/data_tree/fields/nest.d.ts

@@ -0,0 +1,43 @@
+import type { Tag } from '@malloydata/malloy-tag';
+import { FieldBase } from './base';
+import { Field } from '.';
+import type { ArrayFieldInfo, FieldRegistry, RecordFieldInfo, RepeatedRecordFieldInfo, SortableField } from '../types';
+import type { NestField } from '.';
+export declare class ArrayField extends FieldBase {
+    readonly field: ArrayFieldInfo;
+    readonly fields: Field[];
+    readonly maxUniqueFieldValueCounts: Map<string, number>;
+    readonly eachField: Field;
+    constructor(field: ArrayFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    get isDrillable(): boolean;
+}
+export declare class RepeatedRecordField extends ArrayField {
+    readonly field: RepeatedRecordFieldInfo;
+    readonly fields: Field[];
+    maxRecordCount: number;
+    constructor(field: RepeatedRecordFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    fieldAtPath(path: string[]): Field;
+    registerRecordCount(count: number): void;
+    registerValueSetSize(fieldName: string, size: number): void;
+    private _fieldsWithOrder;
+    get fieldsWithOrder(): SortableField[];
+}
+export declare class RootField extends RepeatedRecordField {
+    readonly field: RepeatedRecordFieldInfo;
+    readonly modelTag: Tag;
+    readonly queryTimezone: string | undefined;
+    constructor(field: RepeatedRecordFieldInfo, metadata: {
+        modelTag: Tag;
+        queryTimezone: string | undefined;
+    }, registry?: FieldRegistry);
+}
+export declare class RecordField extends FieldBase {
+    readonly field: RecordFieldInfo;
+    readonly fields: Field[];
+    readonly fieldsByName: Record<string, Field>;
+    readonly maxUniqueFieldValueCounts: Map<string, number>;
+    constructor(field: RecordFieldInfo, parent: NestField | undefined, registry?: FieldRegistry);
+    fieldAtPath(path: string[]): Field;
+    private _fieldsWithOrder;
+    get fieldsWithOrder(): SortableField[];
+}

package/dist/data_tree/index.d.ts

@@ -0,0 +1,11 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import { RootCell } from './cells';
+import type { RenderPlugin } from './plugins';
+export declare function getDataTree(result: Malloy.Result, plugins?: RenderPlugin[]): RootCell;
+export * from './cells/base';
+export * from './types';
+export * from './plugins';
+export * from './fields';
+export * from './cells';
+export * from './utils';
+export * from './drilling';

package/dist/data_tree/plugins.d.ts

@@ -0,0 +1,14 @@
+import type { Tag } from '@malloydata/malloy-tag';
+import type { Field, NestField } from './fields';
+import type { NestCell } from './cells';
+import type { FieldType } from './types';
+export type RenderPluginInstance = {
+    name: string;
+    processData(field: NestField, cell: NestCell): void;
+};
+export type RenderPlugin<T extends RenderPluginInstance = RenderPluginInstance> = {
+    name: string;
+    matches: (fieldTag: Tag, fieldType: FieldType) => boolean;
+    plugin: RenderPluginFactory<T>;
+};
+export type RenderPluginFactory<T extends RenderPluginInstance> = (field: Field) => T;

package/dist/data_tree/types.d.ts

@@ -0,0 +1,68 @@
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { Field } from './fields';
+import type { RenderPluginInstance } from './plugins';
+import type { Cell } from './cells';
+export type DrillEntry = {
+    field: Field;
+    value: string | number | boolean | Date | null;
+} | {
+    where: string;
+};
+export type DrillValue = {
+    field: Field;
+    value: Cell;
+} | {
+    where: string;
+};
+export interface FieldRegistry {
+    fieldInstances: Map<string, Field[]>;
+    plugins: Map<string, RenderPluginInstance[]>;
+}
+export type SortableField = {
+    field: Field;
+    dir: 'asc' | 'desc' | undefined;
+};
+export type ArrayFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithArrayType;
+};
+export type RepeatedRecordFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithArrayType & {
+        element_type: Malloy.AtomicTypeWithRecordType;
+    };
+};
+export type RecordFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithRecordType;
+};
+export type NumberFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithNumberType;
+};
+export type DateFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithDateType;
+};
+export type JSONFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithJSONType;
+};
+export type StringFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithStringType;
+};
+export type TimestampFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithTimestampType;
+};
+export type BooleanFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithBooleanType;
+};
+export type SQLNativeFieldInfo = Malloy.DimensionInfo & {
+    type: Malloy.AtomicTypeWithSQLNativeType;
+};
+export declare enum FieldType {
+    Array = "array",
+    RepeatedRecord = "repeated_record",
+    Record = "record",
+    Number = "number",
+    Date = "date",
+    JSON = "json",
+    String = "string",
+    Timestamp = "timestamp",
+    Boolean = "boolean",
+    SQLNative = "sql_native"
+}

package/dist/data_tree/utils.d.ts

@@ -0,0 +1,19 @@
+import type { Tag } from '@malloydata/malloy-tag';
+import type * as Malloy from '@malloydata/malloy-interfaces';
+import type { BooleanFieldInfo, DateFieldInfo, JSONFieldInfo, NumberFieldInfo, RecordFieldInfo, RepeatedRecordFieldInfo, ArrayFieldInfo, SQLNativeFieldInfo, StringFieldInfo, TimestampFieldInfo } from './types';
+import { FieldType } from './types';
+import { type Field } from './fields';
+export declare function isArrayFieldInfo(field: Malloy.DimensionInfo): field is ArrayFieldInfo;
+export declare function isRepeatedRecordFieldInfo(field: Malloy.DimensionInfo): field is RepeatedRecordFieldInfo;
+export declare function isRecordFieldInfo(field: Malloy.DimensionInfo): field is RecordFieldInfo;
+export declare function isNumberFieldInfo(field: Malloy.DimensionInfo): field is NumberFieldInfo;
+export declare function isDateFieldInfo(field: Malloy.DimensionInfo): field is DateFieldInfo;
+export declare function isJSONFieldInfo(field: Malloy.DimensionInfo): field is JSONFieldInfo;
+export declare function isStringFieldInfo(field: Malloy.DimensionInfo): field is StringFieldInfo;
+export declare function isTimestampFieldInfo(field: Malloy.DimensionInfo): field is TimestampFieldInfo;
+export declare function isBooleanFieldInfo(field: Malloy.DimensionInfo): field is BooleanFieldInfo;
+export declare function isSQLNativeFieldInfo(field: Malloy.DimensionInfo): field is SQLNativeFieldInfo;
+export declare function shouldRenderAs(field: Malloy.DimensionInfo, parent: Field | undefined, tagOverride?: Tag): string;
+export declare function tagFor(field: Malloy.DimensionInfo, prefix?: string): Tag;
+export declare function extractLiteralFromTag(value: Tag | undefined): Malloy.LiteralValue | undefined;
+export declare function getFieldType(field: Field): FieldType;

package/dist/html/html_view.d.ts

@@ -4,11 +4,10 @@ import type { Renderer } from './renderer';
 import type { RendererOptions } from './renderer_types';
 import type * as Malloy from '@malloydata/malloy-interfaces';
 import type { Cell, Field } from '../data_tree';
-import { Result } from '@malloydata/malloy';
 export declare class HTMLView {
     private document;
     constructor(document: Document);
-    render(result: Result | Malloy.Result, options: RendererOptions): Promise<HTMLElement>;
+    render(malloyResult: Malloy.Result, options: RendererOptions): Promise<HTMLElement>;
 }
 export declare class JSONView {
     private document;

package/dist/html/renderer_types.d.ts

@@ -7,5 +7,6 @@ export interface RendererOptions {
     titleCase?: boolean;
     queryTimezone?: string;
     nextRendererOptions?: Partial<MalloyRenderProps>;
+    useLegacy?: boolean;
 }
 export type DrillFunction = (drillQuery: string, target: HTMLElement, drillFilters: string[]) => void;

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { HTMLView, JSONView } from './html/html_view';
 export * from './html/data_styles';
 export type { MalloyRenderProps } from './component/render';
-export { getDataTree } from './data_tree';
-export { copyMalloyRenderHTML, getMalloyRenderHTML, } from './component/copy-to-html';
+export { MalloyRenderer } from '@/api/malloy-renderer';
+export type { MalloyViz } from '@/api/malloy-viz';
+export type { MalloyRendererOptions, RenderFieldMetadata } from '@/api/types';
+export type { DrillData, MalloyClickEventPayload, TableConfig, DashboardConfig, VegaConfigHandler, } from '@/component/types';