@stonecrop/schema 0.10.15 → 0.11.0

package/dist/schema.d.ts

@@ -58,6 +58,23 @@ export declare function camelToLabel(camelCase: string): string;
  */
 export declare function camelToSnake(camelCase: string): string;
 
+/**
+ * Cardinality for relationship links.
+ * @public
+ */
+export declare const Cardinality: z.ZodEnum<{
+    one: "one";
+    atMostOne: "atMostOne";
+    noneOrMany: "noneOrMany";
+    atLeastOne: "atLeastOne";
+}>;
+
+/**
+ * Cardinality type inferred from Zod schema
+ * @public
+ */
+export declare type Cardinality = z.infer<typeof Cardinality>;
+
 /**
  * Classify a single GraphQL field into a Stonecrop field definition.
  *
@@ -123,6 +140,21 @@ export declare interface ConvertedGraphQLDoctype extends Omit<DoctypeMeta, 'fiel
  */
 export declare function convertGraphQLSchema(source: IntrospectionSource, options?: GraphQLConversionOptions): ConvertedGraphQLDoctype[];
 
+/**
+ * Custom fetch strategy - uses a custom handler function.
+ * @public
+ */
+export declare const CustomFetch: z.ZodObject<{
+    method: z.ZodLiteral<"custom">;
+    handler: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Custom fetch strategy type
+ * @public
+ */
+export declare type CustomFetch = z.infer<typeof CustomFetch>;
+
 /**
  * Interface for data clients that fetch doctype metadata and records.
  * Implemented by \@stonecrop/graphql-client's StonecropClient.
@@ -141,23 +173,23 @@ export declare interface DataClient<T extends DoctypeRef = DoctypeRef, M = Docty
     getMeta(context: DoctypeContext): Promise<M | null>;
     /**
      * Fetch a single record by ID
+     *
+     * When `includeNested` is set, builds a query with sub-selections for descendant
+     * links and returns ancestor + merged descendants. When omitted, returns flat scalar data.
+     *
      * @param doctype - Doctype reference (name and optional slug)
      * @param recordId - Record ID to fetch
+     * @param options - Query options
      * @returns Record data or null if not found
      */
-    getRecord(doctype: T, recordId: string): Promise<Record<string, unknown> | null>;
+    getRecord(doctype: T, recordId: string, options?: GetRecordOptions): Promise<Record<string, unknown> | null>;
     /**
      * Fetch multiple records
      * @param doctype - Doctype reference (name and optional slug)
-     * @param options - Optional filters, pagination, sorting
+     * @param options - Query options
      * @returns Array of record data
      */
-    getRecords(doctype: T, options?: {
-        filters?: Record<string, unknown>;
-        orderBy?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<Record<string, unknown>[]>;
+    getRecords(doctype: T, options?: GetRecordsOptions): Promise<Record<string, unknown>[]>;
     /**
      * Execute a doctype action (e.g., SUBMIT, APPROVE, save).
      * All state changes flow through this single mutation endpoint.
@@ -221,7 +253,7 @@ export declare interface DoctypeContext {
  * Doctype metadata - complete definition of a doctype
  * @public
  */
-declare const DoctypeMeta: z.ZodObject<{
+export declare const DoctypeMeta: z.ZodObject<{
     name: z.ZodString;
     slug: z.ZodOptional<z.ZodString>;
     tableName: z.ZodOptional<z.ZodString>;
@@ -242,7 +274,6 @@ declare const DoctypeMeta: z.ZodObject<{
             JSON: "JSON";
             Code: "Code";
             Link: "Link";
-            Doctype: "Doctype";
             Attach: "Attach";
             Currency: "Currency";
             Quantity: "Quantity";
@@ -267,13 +298,37 @@ declare const DoctypeMeta: z.ZodObject<{
         options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
         cardinality: z.ZodOptional<z.ZodEnum<{
             one: "one";
-            many: "many";
+            atMostOne: "atMostOne";
+            noneOrMany: "noneOrMany";
+            atLeastOne: "atLeastOne";
         }>>;
         mask: z.ZodOptional<z.ZodString>;
         validation: z.ZodOptional<z.ZodObject<{
             errorMessage: z.ZodString;
         }, z.core.$loose>>;
     }, z.core.$strip>>;
+    links: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        target: z.ZodString;
+        cardinality: z.ZodEnum<{
+            one: "one";
+            atMostOne: "atMostOne";
+            noneOrMany: "noneOrMany";
+            atLeastOne: "atLeastOne";
+        }>;
+        backlink: z.ZodOptional<z.ZodString>;
+        component: z.ZodOptional<z.ZodString>;
+        fieldname: z.ZodOptional<z.ZodString>;
+        fetch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            method: z.ZodLiteral<"sync">;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            method: z.ZodLiteral<"lazy">;
+        }, z.core.$strip>, z.ZodObject<{
+            method: z.ZodLiteral<"custom">;
+            handler: z.ZodString;
+        }, z.core.$strip>], "method">>;
+        blockWorkflows: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
     workflow: z.ZodOptional<z.ZodObject<{
         states: z.ZodOptional<z.ZodArray<z.ZodString>>;
         actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -286,17 +341,13 @@ declare const DoctypeMeta: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     inherits: z.ZodOptional<z.ZodString>;
-    listDoctype: z.ZodOptional<z.ZodString>;
-    parentDoctype: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
 /**
  * Doctype metadata type inferred from Zod schema
  * @public
  */
-declare type DoctypeMeta = z.infer<typeof DoctypeMeta>;
-export { DoctypeMeta }
-export { DoctypeMeta as DoctypeMetaType }
+export declare type DoctypeMeta = z.infer<typeof DoctypeMeta>;
 
 /**
  * Base interface for doctype metadata passed to DataClient methods.
@@ -310,6 +361,29 @@ export declare interface DoctypeRef {
     slug?: string;
 }
 
+/**
+ * Fetch strategy for link data loading.
+ * - sync: fetched in the initial query
+ * - lazy: fetched on demand in a separate query
+ * - custom: uses a custom handler function
+ * @public
+ */
+export declare const FetchStrategy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    method: z.ZodLiteral<"sync">;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    method: z.ZodLiteral<"lazy">;
+}, z.core.$strip>, z.ZodObject<{
+    method: z.ZodLiteral<"custom">;
+    handler: z.ZodString;
+}, z.core.$strip>], "method">;
+
+/**
+ * Fetch strategy type
+ * @public
+ */
+export declare type FetchStrategy = z.infer<typeof FetchStrategy>;
+
 /**
  * Unified field metadata - the single source of truth for field definitions.
  * Works for both forms (AForm) and tables (ATable).
@@ -318,7 +392,7 @@ export declare interface DoctypeRef {
  *
  * @public
  */
-declare const FieldMeta: z.ZodObject<{
+export declare const FieldMeta: z.ZodObject<{
     fieldname: z.ZodString;
     fieldtype: z.ZodEnum<{
         Data: "Data";
@@ -335,7 +409,6 @@ declare const FieldMeta: z.ZodObject<{
         JSON: "JSON";
         Code: "Code";
         Link: "Link";
-        Doctype: "Doctype";
         Attach: "Attach";
         Currency: "Currency";
         Quantity: "Quantity";
@@ -360,7 +433,9 @@ declare const FieldMeta: z.ZodObject<{
     options: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
     cardinality: z.ZodOptional<z.ZodEnum<{
         one: "one";
-        many: "many";
+        atMostOne: "atMostOne";
+        noneOrMany: "noneOrMany";
+        atLeastOne: "atLeastOne";
     }>>;
     mask: z.ZodOptional<z.ZodString>;
     validation: z.ZodOptional<z.ZodObject<{
@@ -373,9 +448,7 @@ declare const FieldMeta: z.ZodObject<{
  * Field metadata type inferred from Zod schema
  * @public
  */
-declare type FieldMeta = z.infer<typeof FieldMeta>;
-export { FieldMeta }
-export { FieldMeta as FieldMetaType }
+export declare type FieldMeta = z.infer<typeof FieldMeta>;
 
 /**
  * Field options - flexible bag for type-specific configuration.
@@ -388,15 +461,13 @@ export { FieldMeta as FieldMetaType }
  *
  * @public
  */
-declare const FieldOptions: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+export declare const FieldOptions: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
 
 /**
  * Field options type inferred from Zod schema
  * @public
  */
-declare type FieldOptions = z.infer<typeof FieldOptions>;
-export { FieldOptions }
-export { FieldOptions as FieldOptionsType }
+export declare type FieldOptions = z.infer<typeof FieldOptions>;
 
 /**
  * Field template for TYPE_MAP entries.
@@ -437,6 +508,40 @@ export declare type FieldValidation = z.infer<typeof FieldValidation>;
  */
 export declare function getDefaultComponent(fieldtype: StonecropFieldType): string;
 
+/**
+ * Options for fetching a single record
+ * @public
+ */
+export declare interface GetRecordOptions {
+    /**
+     * Include nested link sub-selections.
+     * - `true`: include all descendant links
+     * - `string[]`: include only named links
+     * - `false` / omitted: scalar fields only (default)
+     */
+    includeNested?: boolean | string[];
+    /**
+     * Maximum depth for recursive sub-selections.
+     * No default — unlimited when omitted.
+     */
+    maxDepth?: number;
+}
+
+/**
+ * Options for fetching multiple records
+ * @public
+ */
+export declare interface GetRecordsOptions {
+    /** Filter expression (field-value pairs) */
+    filters?: Record<string, unknown>;
+    /** Order by expression (e.g. 'NAME_ASC') */
+    orderBy?: string;
+    /** Maximum number of records to return */
+    limit?: number;
+    /** Number of records to skip */
+    offset?: number;
+}
+
 /**
  * Mapping from standard GraphQL scalar types to Stonecrop field types.
  * These are defined by the GraphQL specification and are always available.
@@ -456,6 +561,8 @@ export declare interface GraphQLConversionFieldMeta extends FieldMeta {
     _graphqlType?: string;
     /** Marks fields that couldn't be automatically mapped */
     _unmapped?: boolean;
+    /** Marks relationship fields that belong in `links`, not `fields` */
+    _isLink?: boolean;
 }
 
 /**
@@ -579,6 +686,53 @@ export declare const INTERNAL_SCALARS: Set<string>;
  */
 export declare type IntrospectionSource = IntrospectionQuery | string;
 
+/**
+ * Lazy fetch strategy - data is fetched on demand in a separate query.
+ * @public
+ */
+export declare const LazyFetch: z.ZodObject<{
+    method: z.ZodLiteral<"lazy">;
+}, z.core.$strip>;
+
+/**
+ * Lazy fetch strategy type
+ * @public
+ */
+export declare type LazyFetch = z.infer<typeof LazyFetch>;
+
+/**
+ * Link declaration - describes a relationship from one doctype to another.
+ * @public
+ */
+export declare const LinkDeclaration: z.ZodObject<{
+    target: z.ZodString;
+    cardinality: z.ZodEnum<{
+        one: "one";
+        atMostOne: "atMostOne";
+        noneOrMany: "noneOrMany";
+        atLeastOne: "atLeastOne";
+    }>;
+    backlink: z.ZodOptional<z.ZodString>;
+    component: z.ZodOptional<z.ZodString>;
+    fieldname: z.ZodOptional<z.ZodString>;
+    fetch: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        method: z.ZodLiteral<"sync">;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        method: z.ZodLiteral<"lazy">;
+    }, z.core.$strip>, z.ZodObject<{
+        method: z.ZodLiteral<"custom">;
+        handler: z.ZodString;
+    }, z.core.$strip>], "method">>;
+    blockWorkflows: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/**
+ * Link declaration type inferred from Zod schema
+ * @public
+ */
+export declare type LinkDeclaration = z.infer<typeof LinkDeclaration>;
+
 /**
  * Parse and validate a doctype, throwing on failure
  * @param data - Data to parse
@@ -610,6 +764,13 @@ export declare function parseField(data: unknown): FieldMeta;
  */
 export declare function pascalToSnake(pascal: string): string;
 
+/**
+ * Serialized function type - a function serialized to a string.
+ * Used for custom fetch handlers.
+ * @public
+ */
+export declare type SerializedFunction = string;
+
 /**
  * Converts snake_case to camelCase
  * @param snakeCase - Snake case string
@@ -641,7 +802,7 @@ export declare function snakeToLabel(snakeCase: string): string;
  * These are consistent across forms and tables.
  * @public
  */
-declare const StonecropFieldType: z.ZodEnum<{
+export declare const StonecropFieldType: z.ZodEnum<{
     Data: "Data";
     Text: "Text";
     Int: "Int";
@@ -656,7 +817,6 @@ declare const StonecropFieldType: z.ZodEnum<{
     JSON: "JSON";
     Code: "Code";
     Link: "Link";
-    Doctype: "Doctype";
     Attach: "Attach";
     Currency: "Currency";
     Quantity: "Quantity";
@@ -667,9 +827,22 @@ declare const StonecropFieldType: z.ZodEnum<{
  * Stonecrop field type enum inferred from Zod schema
  * @public
  */
-declare type StonecropFieldType = z.infer<typeof StonecropFieldType>;
-export { StonecropFieldType }
-export { StonecropFieldType as StonecropFieldTypeValue }
+export declare type StonecropFieldType = z.infer<typeof StonecropFieldType>;
+
+/**
+ * Sync fetch strategy - data is fetched in the initial query.
+ * @public
+ */
+export declare const SyncFetch: z.ZodObject<{
+    method: z.ZodLiteral<"sync">;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/**
+ * Sync fetch strategy type
+ * @public
+ */
+export declare type SyncFetch = z.infer<typeof SyncFetch>;
 
 /**
  * Convert table name to PascalCase doctype name
@@ -748,7 +921,7 @@ export declare const WELL_KNOWN_SCALARS: Record<string, FieldTemplate>;
  * Workflow metadata - states and actions for a doctype
  * @public
  */
-declare const WorkflowMeta: z.ZodObject<{
+export declare const WorkflowMeta: z.ZodObject<{
     states: z.ZodOptional<z.ZodArray<z.ZodString>>;
     actions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         label: z.ZodString;
@@ -764,8 +937,6 @@ declare const WorkflowMeta: z.ZodObject<{
  * Workflow metadata type inferred from Zod schema
  * @public
  */
-declare type WorkflowMeta = z.infer<typeof WorkflowMeta>;
-export { WorkflowMeta }
-export { WorkflowMeta as WorkflowMetaType }
+export declare type WorkflowMeta = z.infer<typeof WorkflowMeta>;
 
 export { }

package/dist/src/cli.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * Stonecrop Schema CLI
+ *
+ * Converts GraphQL introspection results to Stonecrop doctype JSON schemas.
+ *
+ * Usage:
+ *   stonecrop-schema generate --endpoint <url> --output <dir>
+ *   stonecrop-schema generate --introspection <file.json> --output <dir>
+ *   stonecrop-schema generate --sdl <file.graphql> --output <dir>
+ *
+ * @packageDocumentation
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+import { parseArgs } from 'node:util';
+import { getIntrospectionQuery } from 'graphql';
+import { convertGraphQLSchema } from './converter/index';
+import { validateDoctype } from './validation';
+/**
+ * Fetch an introspection result from a live GraphQL endpoint.
+ *
+ * @param endpoint - The GraphQL endpoint URL
+ * @param headers - Optional HTTP headers
+ * @returns The introspection query result
+ */
+async function fetchIntrospection(endpoint, headers) {
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            ...headers,
+        },
+        body: JSON.stringify({
+            query: getIntrospectionQuery(),
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch introspection: ${response.status} ${response.statusText}`);
+    }
+    const json = (await response.json());
+    if (json.errors?.length) {
+        throw new Error(`GraphQL errors: ${json.errors.map(e => e.message).join(', ')}`);
+    }
+    if (!json.data) {
+        throw new Error('No data in introspection response');
+    }
+    return json.data;
+}
+async function main() {
+    const { values, positionals } = parseArgs({
+        allowPositionals: true,
+        options: {
+            endpoint: { type: 'string', short: 'e' },
+            introspection: { type: 'string', short: 'i' },
+            sdl: { type: 'string', short: 's' },
+            output: { type: 'string', short: 'o' },
+            include: { type: 'string' },
+            exclude: { type: 'string' },
+            overrides: { type: 'string' },
+            'custom-scalars': { type: 'string' },
+            'include-unmapped': { type: 'boolean', default: false },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    const command = positionals[0];
+    if (values.help || !command) {
+        printHelp();
+        process.exit(command ? 0 : 1);
+    }
+    if (command !== 'generate') {
+        console.error(`Unknown command: ${command}`);
+        console.error('Available commands: generate');
+        process.exit(1);
+    }
+    // Determine source
+    const sourceCount = [values.endpoint, values.introspection, values.sdl].filter(Boolean).length;
+    if (sourceCount !== 1) {
+        console.error('Exactly one of --endpoint, --introspection, or --sdl must be provided');
+        process.exit(1);
+    }
+    if (!values.output) {
+        console.error('--output <dir> is required');
+        process.exit(1);
+    }
+    const outputDir = resolve(values.output);
+    // Build conversion options
+    const options = {
+        includeUnmappedMeta: values['include-unmapped'],
+    };
+    if (values.include) {
+        options.include = values.include.split(',').map(s => s.trim());
+    }
+    if (values.exclude) {
+        options.exclude = values.exclude.split(',').map(s => s.trim());
+    }
+    if (values.overrides) {
+        const overridesPath = resolve(values.overrides);
+        const overridesContent = readFileSync(overridesPath, 'utf-8');
+        options.typeOverrides = JSON.parse(overridesContent);
+    }
+    if (values['custom-scalars']) {
+        const scalarsPath = resolve(values['custom-scalars']);
+        const scalarsContent = readFileSync(scalarsPath, 'utf-8');
+        options.customScalars = JSON.parse(scalarsContent);
+    }
+    // Resolve source
+    let source;
+    if (values.endpoint) {
+        console.log(`Fetching introspection from ${values.endpoint}...`);
+        source = await fetchIntrospection(values.endpoint);
+    }
+    else if (values.introspection) {
+        const filePath = resolve(values.introspection);
+        const content = readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Handle both { data: { __schema: ... } } and { __schema: ... } formats
+        source = parsed.data ?? parsed;
+    }
+    else {
+        const filePath = resolve(values.sdl);
+        source = readFileSync(filePath, 'utf-8');
+    }
+    // Convert
+    const doctypes = convertGraphQLSchema(source, options);
+    if (doctypes.length === 0) {
+        console.warn('No entity types found in the schema. Check your include/exclude filters.');
+        process.exit(0);
+    }
+    // Write output
+    if (!existsSync(outputDir)) {
+        mkdirSync(outputDir, { recursive: true });
+    }
+    let warnings = 0;
+    let errors = 0;
+    for (const doctype of doctypes) {
+        const fileName = `${doctype.slug}.json`;
+        const filePath = join(outputDir, fileName);
+        const json = JSON.stringify(doctype, null, '\t');
+        writeFileSync(filePath, json + '\n', 'utf-8');
+        // Validate the output
+        const validation = validateDoctype(doctype);
+        if (!validation.success) {
+            errors++;
+            console.error(`  ERROR: ${fileName} failed validation:`);
+            for (const err of validation.errors) {
+                console.error(`    ${err.path.join('.')}: ${err.message}`);
+            }
+        }
+        else {
+            // Check for unmapped fields
+            const unmappedFields = doctype.fields.filter((f) => f._unmapped);
+            if (unmappedFields.length > 0) {
+                warnings++;
+                console.warn(`  WARN: ${fileName} has ${unmappedFields.length} unmapped field(s): ${unmappedFields
+                    .map((f) => f.fieldname)
+                    .join(', ')}`);
+            }
+        }
+    }
+    console.log(`\nGenerated ${doctypes.length} doctype(s) in ${outputDir}` +
+        (warnings ? ` (${warnings} with warnings)` : '') +
+        (errors ? ` (${errors} with errors)` : ''));
+    if (errors > 0) {
+        process.exit(1);
+    }
+}
+function printHelp() {
+    console.log(`
+stonecrop-schema - Convert GraphQL schemas to Stonecrop doctypes
+
+USAGE:
+  stonecrop-schema generate [options]
+
+SOURCE (exactly one required):
+  --endpoint, -e <url>         Fetch introspection from a live GraphQL endpoint
+  --introspection, -i <file>   Read from a saved introspection JSON file
+  --sdl, -s <file>             Read from a GraphQL SDL (.graphql) file
+
+OUTPUT:
+  --output, -o <dir>           Directory to write doctype JSON files (required)
+
+OPTIONS:
+  --include <types>            Comma-separated list of type names to include
+  --exclude <types>            Comma-separated list of type names to exclude
+  --overrides <file>           JSON file with per-type field overrides
+  --custom-scalars <file>      JSON file mapping custom scalar names to field templates
+  --include-unmapped           Include _graphqlType metadata on unmapped fields
+  --help, -h                   Show this help message
+
+EXAMPLES:
+  # From a live PostGraphile server
+  stonecrop-schema generate -e http://localhost:5000/graphql -o ./schemas
+
+  # From a saved introspection result
+  stonecrop-schema generate -i introspection.json -o ./schemas
+
+  # From an SDL file with custom scalars
+  stonecrop-schema generate -s schema.graphql -o ./schemas \\
+    --custom-scalars custom-scalars.json
+
+  # Only convert specific types
+  stonecrop-schema generate -e http://localhost:5000/graphql -o ./schemas \\
+    --include "User,Post,Comment"
+`);
+}
+main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});

package/dist/src/converter/heuristics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heuristics.d.ts","sourceRoot":"","sources":["../../../src/converter/heuristics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAMN,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAGjB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AA+BnF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CA8BtF;AAQD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACtC,WAAW,EAAE,iBAAiB,GAC5B,OAAO,CAET;AAsED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,OAAO,GAAE,wBAA6B,GACpC,0BAA0B,CA2F5B"}
+{"version":3,"file":"heuristics.d.ts","sourceRoot":"","sources":["../../../src/converter/heuristics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAMN,KAAK,iBAAiB,EACtB,KAAK,YAAY,EAGjB,MAAM,SAAS,CAAA;AAGhB,OAAO,KAAK,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AA+BnF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CA8BtF;AAQD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACtC,WAAW,EAAE,iBAAiB,GAC5B,OAAO,CAET;AAsED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,EACrC,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,OAAO,GAAE,wBAA6B,GACpC,0BAA0B,CA6F5B"}