@platformos/platformos-language-server-common 0.0.6 → 0.0.8

package/dist/TypeSystem.js

@@ -8,19 +8,16 @@ exports.isUnionType = isUnionType;
 exports.typeToDisplayString = typeToDisplayString;
 const liquid_html_parser_1 = require("@platformos/liquid-html-parser");
 const platformos_check_common_1 = require("@platformos/platformos-check-common");
-const settings_1 = require("./settings");
 const utils_1 = require("./utils");
 const platformos_check_common_2 = require("@platformos/platformos-check-common");
 const PropertyShapeInference_1 = require("./PropertyShapeInference");
 const vscode_uri_1 = require("vscode-uri");
 class TypeSystem {
-    constructor(themeDocset, getThemeSettingsSchemaForURI, getMetafieldDefinitions, fs, documentsLocator, findThemeRootURI) {
-        this.themeDocset = themeDocset;
-        this.getThemeSettingsSchemaForURI = getThemeSettingsSchemaForURI;
-        this.getMetafieldDefinitions = getMetafieldDefinitions;
+    constructor(platformosDocset, fs, documentsLocator, findAppRootURI) {
+        this.platformosDocset = platformosDocset;
         this.fs = fs;
         this.documentsLocator = documentsLocator;
-        this.findThemeRootURI = findThemeRootURI;
+        this.findAppRootURI = findAppRootURI;
         this.graphqlSchemaLoaded = false;
         /**
          * An indexed representation of objects.json by name
@@ -28,72 +25,7 @@ class TypeSystem {
          * e.g. objectMap['product'] returns the product ObjectEntry.
          */
         this.objectMap = async (uri, ast) => {
-            const [objectMap, themeSettingProperties, metafieldDefinitionsObjectMap] = await Promise.all([
-                this._objectMap(),
-                this.themeSettingProperties(uri),
-                this.metafieldDefinitionsObjectMap(uri),
-            ]);
-            // Here we shallow mutate `settings.properties` to have the properties made
-            // available by settings_schema.json
-            const result = {
-                ...objectMap,
-                settings: {
-                    ...(objectMap.settings ?? {}),
-                    properties: themeSettingProperties,
-                },
-                ...customMetafieldTypeEntries(objectMap['metafield']),
-                ...metafieldDefinitionsObjectMap,
-            };
-            // For each metafield definition fetched, we need to override existing types with `metafields` property
-            // to `${category}_metafield`.
-            //
-            // WARNING: Since we aren't cloning the object, we are mutating the original type for all themes in
-            // the workspace. However, this is fine since these changes are not unique to a theme.
-            for (let category of platformos_check_common_1.FETCHED_METAFIELD_CATEGORIES) {
-                if (!result[category])
-                    continue;
-                let metafieldsProperty = result[category].properties?.find((prop) => prop.name === 'metafields');
-                if (!metafieldsProperty)
-                    continue;
-                metafieldsProperty.return_type = [{ type: `${category}_metafields`, name: '' }];
-            }
-            // Deal with sections/file.liquid section.settings by infering the type from the {% schema %}
-            if (/[\/\\]sections[\/\\]/.test(uri) && result.section) {
-                result.section = JSON.parse(JSON.stringify(result.section)); // easy deep clone
-                const settings = result.section.properties?.find((x) => x.name === 'settings');
-                if (!settings || !settings.return_type)
-                    return result;
-                settings.return_type = [{ type: 'section_settings', name: '' }];
-                result.section_settings = {
-                    name: 'section_settings',
-                    access: {
-                        global: false,
-                        parents: [],
-                        template: [],
-                    },
-                    properties: schemaSettingsAsProperties(ast),
-                    return_type: [],
-                };
-            }
-            // Deal with blocks/files.liquid block.settings in a similar fashion
-            if (/[\/\\]blocks[\/\\]/.test(uri) && result.block) {
-                result.block = JSON.parse(JSON.stringify(result.block)); // easy deep clone
-                const settings = result.block.properties?.find((x) => x.name === 'settings');
-                if (!settings || !settings.return_type)
-                    return result;
-                settings.return_type = [{ type: 'block_settings', name: '' }];
-                result.block_settings = {
-                    name: 'block_settings',
-                    access: {
-                        global: false,
-                        parents: [],
-                        template: [],
-                    },
-                    properties: schemaSettingsAsProperties(ast),
-                    return_type: [],
-                };
-            }
-            return result;
+            return this._objectMap();
         };
         // This is the big one we reuse (memoized)
         this._objectMap = (0, utils_1.memo)(async () => {
@@ -112,10 +44,10 @@ class TypeSystem {
             }, {});
         });
         this.filterEntries = (0, utils_1.memo)(async () => {
-            return this.themeDocset.filters();
+            return this.platformosDocset.filters();
         });
         this.objectEntries = (0, utils_1.memo)(async () => {
-            return this.themeDocset.objects();
+            return this.platformosDocset.objects();
         });
         /**
          * The seedSymbolsTable contains all the global variables.
@@ -153,7 +85,7 @@ class TypeSystem {
     }
     async getGraphQLSchema() {
         if (!this.graphqlSchemaLoaded) {
-            this.graphqlSchemaCache = (await this.themeDocset.graphQL()) ?? undefined;
+            this.graphqlSchemaCache = (await this.platformosDocset.graphQL()) ?? undefined;
             this.graphqlSchemaLoaded = true;
         }
         return this.graphqlSchemaCache;
@@ -190,87 +122,12 @@ class TypeSystem {
             };
         });
     }
-    async themeSettingProperties(uri) {
-        const themeSettingsSchema = await this.getThemeSettingsSchemaForURI(uri);
-        const categories = themeSettingsSchema.filter(settings_1.isSettingsCategory);
-        const result = [];
-        for (const category of categories) {
-            const inputSettings = category.settings.filter(settings_1.isInputSetting);
-            for (const setting of inputSettings) {
-                result.push({
-                    name: setting.id,
-                    summary: '', // TODO, this should lookup the locale file for settings... setting.label
-                    description: '', // TODO , this should lookup the locale file as well... setting.info,
-                    return_type: settingReturnType(setting),
-                    access: {
-                        global: false,
-                        parents: [],
-                        template: [],
-                    },
-                });
-            }
-        }
-        return result;
-    }
-    async metafieldDefinitionsObjectMap(uri) {
-        let result = {};
-        const metafieldDefinitionMap = await this.getMetafieldDefinitions(uri);
-        for (let [category, definitions] of Object.entries(metafieldDefinitionMap)) {
-            // Metafield definitions need to be grouped by their namespace
-            let metafieldNamespaces = new Map();
-            for (let definition of definitions) {
-                if (!metafieldNamespaces.has(definition.namespace)) {
-                    metafieldNamespaces.set(definition.namespace, []);
-                }
-                metafieldNamespaces.get(definition.namespace).push({
-                    name: definition.key,
-                    description: definition.description,
-                    return_type: metafieldReturnType(definition.type.name),
-                });
-            }
-            let metafieldGroupProperties = [];
-            for (let [namespace, namespaceProperties] of metafieldNamespaces) {
-                const metafieldCategoryNamespaceHandle = `${category}_metafield_${namespace}`;
-                // Since the namespace can be shared by multiple categories, we need to make sure the return_type
-                // handle is unique across all categories
-                metafieldGroupProperties.push({
-                    name: namespace,
-                    return_type: [{ type: metafieldCategoryNamespaceHandle, name: '' }],
-                    access: {
-                        global: false,
-                        parents: [],
-                        template: [],
-                    },
-                });
-                result[metafieldCategoryNamespaceHandle] = {
-                    name: metafieldCategoryNamespaceHandle,
-                    properties: namespaceProperties,
-                    access: {
-                        global: false,
-                        parents: [],
-                        template: [],
-                    },
-                };
-            }
-            const metafieldCategoryHandle = `${category}_metafields`;
-            result[metafieldCategoryHandle] = {
-                name: metafieldCategoryHandle,
-                properties: metafieldGroupProperties,
-                access: {
-                    global: false,
-                    parents: [],
-                    template: [],
-                },
-            };
-        }
-        return result;
-    }
     async symbolsTable(partialAst, uri) {
         const [seedSymbolsTable, liquidDrops, graphqlSchema, rootUri, objectMap, filtersMap] = await Promise.all([
             this.seedSymbolsTable(uri),
-            this.themeDocset.liquidDrops(),
+            this.platformosDocset.liquidDrops(),
             this.getGraphQLSchema(),
-            this.findThemeRootURI?.(uri) ?? null,
+            this.findAppRootURI?.(uri) ?? null,
             this.objectMap(uri, partialAst),
             this.filtersMap(),
         ]);
@@ -279,35 +136,9 @@ class TypeSystem {
     }
 }
 exports.TypeSystem = TypeSystem;
-const SECTION_FILE_REGEX = /sections[\/\\][^.\\\/]*\.liquid$/;
-const BLOCK_FILE_REGEX = /blocks[\/\\][^.\\\/]*\.liquid$/;
 const PARTIAL_FILE_REGEX = /(views[\/\\]partials[\/\\]|[\/\\]lib[\/\\])[^.]*\.liquid$/;
-const LAYOUT_FILE_REGEX = /layout[\/\\]checkout\.liquid$/;
 function getContextualEntries(uri) {
     const normalizedUri = platformos_check_common_1.path.normalize(uri);
-    if (LAYOUT_FILE_REGEX.test(normalizedUri)) {
-        return [
-            'locale',
-            'direction',
-            'skip_to_content_link',
-            'checkout_html_classes',
-            'checkout_stylesheets',
-            'checkout_scripts',
-            'content_for_logo',
-            'breadcrumb',
-            'order_summary_toggle',
-            'content_for_order_summary',
-            'alternative_payment_methods',
-            'content_for_footer',
-            'tracking_code',
-        ];
-    }
-    if (SECTION_FILE_REGEX.test(normalizedUri)) {
-        return ['section', 'predictive_search', 'recommendations', 'comment'];
-    }
-    if (BLOCK_FILE_REGEX.test(normalizedUri)) {
-        return ['app', 'section', 'recommendations', 'block'];
-    }
     if (PARTIAL_FILE_REGEX.test(normalizedUri)) {
         return ['app'];
     }
@@ -346,41 +177,184 @@ async function buildSymbolsTable(partialAst, seedSymbolsTable, liquidDrops, grap
     const typeRanges = await (0, platformos_check_common_2.visit)(partialAst, {
         // {% assign x = foo.x | filter %}
         // {% assign x = '{"a": 1}' | parse_json %}
+        // {% assign x = {a: 1, b: "hello"} %}
+        // {% assign x["key"] = value %}
+        // {% assign arr << item %}
         async AssignMarkup(node) {
-            // Check if this has a parse_json or to_hash filter
-            const hasParseJsonFilter = node.value.filters?.some((f) => f.name === 'parse_json' || f.name === 'to_hash');
-            if (hasParseJsonFilter) {
-                let jsonString;
-                // Check if expression is a direct JSON string
-                if (node.value.expression.type === liquid_html_parser_1.NodeTypes.String) {
-                    jsonString = node.value.expression.value;
+            const expression = node.value.expression;
+            let valueShape;
+            // Resolver for variable references inside JSON literals
+            const resolveExpr = (expr) => {
+                if (expr.type !== liquid_html_parser_1.NodeTypes.VariableLookup || !expr.name)
+                    return undefined;
+                // Look up the variable's shape from already-processed assignments
+                const shapes = variableShapes.get(expr.name);
+                const shapeEntry = shapes
+                    ? findLastApplicableShape(shapes, node.position.start)
+                    : undefined;
+                let shape = shapeEntry?.shape;
+                // Fall back to seedSymbolsTable
+                if (!shape && seedSymbolsTable[expr.name]) {
+                    for (const tr of seedSymbolsTable[expr.name]) {
+                        if (tr.range[0] < node.position.start) {
+                            if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
+                                shape = tr.type.shape;
+                            }
+                            else if (typeof tr.type === 'string' || tr.type.kind === 'array') {
+                                shape = resolvedTypeToShape(tr.type);
+                            }
+                        }
+                    }
                 }
-                // Check if there's a default filter with a JSON string argument
-                if (!jsonString && node.value.filters) {
-                    const defaultFilter = node.value.filters.find((f) => f.name === 'default');
-                    if (defaultFilter && defaultFilter.args && defaultFilter.args.length > 0) {
-                        const firstArg = defaultFilter.args[0];
-                        if (firstArg.type === liquid_html_parser_1.NodeTypes.String) {
-                            jsonString = firstArg.value;
+                if (!shape)
+                    return undefined;
+                // Resolve lookups (e.g. a.x or a["key"])
+                for (const lookup of expr.lookups) {
+                    if (shape.kind === 'object' && lookup.type === liquid_html_parser_1.NodeTypes.String && shape.properties) {
+                        const prop = shape.properties.get(lookup.value);
+                        if (prop) {
+                            shape = prop;
+                        }
+                        else {
+                            return undefined;
+                        }
+                    }
+                    else if (shape.kind === 'array') {
+                        if (lookup.type === liquid_html_parser_1.NodeTypes.Number ||
+                            (lookup.type === liquid_html_parser_1.NodeTypes.String &&
+                                (lookup.value === 'first' || lookup.value === 'last'))) {
+                            shape = shape.itemShape;
+                            if (!shape)
+                                return undefined;
+                        }
+                        else {
+                            return undefined;
                         }
                     }
+                    else {
+                        return undefined;
+                    }
                 }
-                if (jsonString) {
-                    const shape = (0, PropertyShapeInference_1.inferShapeFromJSONString)(jsonString);
-                    if (shape) {
-                        // Track shape for potential hash_assign merging
-                        if (!variableShapes.has(node.name)) {
-                            variableShapes.set(node.name, []);
+                return shape;
+            };
+            // Case 1: JSON literal expression
+            if (expression.type === liquid_html_parser_1.NodeTypes.JsonHashLiteral ||
+                expression.type === liquid_html_parser_1.NodeTypes.JsonArrayLiteral) {
+                valueShape = (0, PropertyShapeInference_1.inferShapeFromJsonLiteral)(expression, resolveExpr);
+            }
+            // Case 2: parse_json / to_hash filter on a string
+            if (!valueShape) {
+                const hasParseJsonFilter = node.value.filters?.some((f) => f.name === 'parse_json' || f.name === 'to_hash');
+                if (hasParseJsonFilter) {
+                    let jsonString;
+                    if (expression.type === liquid_html_parser_1.NodeTypes.String) {
+                        jsonString = expression.value;
+                    }
+                    if (!jsonString && node.value.filters) {
+                        const defaultFilter = node.value.filters.find((f) => f.name === 'default');
+                        if (defaultFilter &&
+                            defaultFilter.args &&
+                            defaultFilter.args.length > 0 &&
+                            defaultFilter.args[0].type === liquid_html_parser_1.NodeTypes.String) {
+                            jsonString = defaultFilter.args[0].value;
                         }
-                        variableShapes.get(node.name).push({ shape, rangeEnd: node.position.end });
-                        return {
-                            identifier: node.name,
-                            type: shapeType(shape),
-                            range: [node.position.end],
-                        };
                     }
+                    if (jsonString) {
+                        valueShape = (0, PropertyShapeInference_1.inferShapeFromJSONString)(jsonString) ?? undefined;
+                    }
+                }
+            }
+            // Case 3: Infer primitive shape for << and LHS lookup scenarios
+            if (!valueShape && ((node.lookups && node.lookups.length > 0) || node.operator === '<<')) {
+                if (expression.type === liquid_html_parser_1.NodeTypes.String) {
+                    valueShape = { kind: 'primitive', primitiveType: 'string' };
+                }
+                else if (expression.type === liquid_html_parser_1.NodeTypes.Number) {
+                    valueShape = { kind: 'primitive', primitiveType: 'number' };
+                }
+                else if (expression.type === liquid_html_parser_1.NodeTypes.LiquidLiteral) {
+                    if (expression.value === null) {
+                        valueShape = { kind: 'primitive', primitiveType: 'null' };
+                    }
+                    else if (typeof expression.value === 'boolean') {
+                        valueShape = { kind: 'primitive', primitiveType: 'boolean' };
+                    }
+                }
+            }
+            // Handle lookups on the LHS (assign x["key"] = value)
+            if (node.lookups && node.lookups.length > 0) {
+                const lookupPath = getAssignLookupPath(node.lookups);
+                if (lookupPath && lookupPath.length > 0) {
+                    const existingShapes = variableShapes.get(node.name) || [];
+                    const existingShapeEntry = findLastApplicableShape(existingShapes, node.position.start);
+                    let baseShape;
+                    if (existingShapeEntry) {
+                        baseShape = existingShapeEntry.shape;
+                    }
+                    else {
+                        let existingType;
+                        if (seedSymbolsTable[node.name]) {
+                            for (const tr of seedSymbolsTable[node.name]) {
+                                if (tr.range[0] < node.position.start) {
+                                    if (typeof tr.type !== 'string' && tr.type.kind === 'shape') {
+                                        existingType = tr.type;
+                                    }
+                                }
+                            }
+                        }
+                        baseShape =
+                            existingType && isShapeType(existingType)
+                                ? existingType.shape
+                                : { kind: 'object', properties: new Map() };
+                    }
+                    const newShape = mergeNestedPropertyIntoShape(baseShape, lookupPath, valueShape ?? { kind: 'primitive' });
+                    if (!variableShapes.has(node.name))
+                        variableShapes.set(node.name, []);
+                    variableShapes.get(node.name).push({ shape: newShape, rangeEnd: node.position.end });
+                    return {
+                        identifier: node.name,
+                        type: shapeType(newShape),
+                        range: [node.position.end],
+                    };
+                }
+            }
+            // Handle << operator (array append)
+            if (node.operator === '<<') {
+                const itemShape = valueShape ?? { kind: 'primitive' };
+                const existingShapes = variableShapes.get(node.name) || [];
+                const existingShapeEntry = findLastApplicableShape(existingShapes, node.position.start);
+                let arrayShape;
+                if (existingShapeEntry?.shape.kind === 'array') {
+                    const existing = existingShapeEntry.shape.itemShape;
+                    arrayShape = {
+                        kind: 'array',
+                        itemShape: existing ? (0, PropertyShapeInference_1.mergeShapes)(existing, itemShape) : itemShape,
+                    };
+                }
+                else {
+                    arrayShape = { kind: 'array', itemShape };
                 }
+                if (!variableShapes.has(node.name))
+                    variableShapes.set(node.name, []);
+                variableShapes.get(node.name).push({ shape: arrayShape, rangeEnd: node.position.end });
+                return {
+                    identifier: node.name,
+                    type: shapeType(arrayShape),
+                    range: [node.position.end],
+                };
             }
+            // Simple assignment with shape (JSON literal or parse_json)
+            if (valueShape) {
+                if (!variableShapes.has(node.name))
+                    variableShapes.set(node.name, []);
+                variableShapes.get(node.name).push({ shape: valueShape, rangeEnd: node.position.end });
+                return {
+                    identifier: node.name,
+                    type: shapeType(valueShape),
+                    range: [node.position.end],
+                };
+            }
+            // Default: lazy variable type
             return {
                 identifier: node.name,
                 type: lazyVariable(node.value, node.position.start),
@@ -417,13 +391,6 @@ async function buildSymbolsTable(partialAst, seedSymbolsTable, liquidDrops, grap
                     range: [node.position.end],
                 };
             }
-            else if (['form', 'paginate'].includes(node.name)) {
-                return {
-                    identifier: node.name,
-                    type: node.name,
-                    range: [node.blockStartPosition.end, end(node.blockEndPosition?.end)],
-                };
-            }
             else if (['for', 'tablerow'].includes(node.name)) {
                 return {
                     identifier: node.name + 'loop',
@@ -731,6 +698,15 @@ function inferType(thing, symbolsTable, objectMap, filtersMap) {
         case liquid_html_parser_1.NodeTypes.Range: {
             return arrayType('number');
         }
+        // JSON literal expressions: {key: val} or [1, 2, 3]
+        case liquid_html_parser_1.NodeTypes.JsonHashLiteral:
+        case liquid_html_parser_1.NodeTypes.JsonArrayLiteral: {
+            const resolver = (expr) => {
+                const type = inferType(expr, symbolsTable, objectMap, filtersMap);
+                return resolvedTypeToShape(type);
+            };
+            return shapeType((0, PropertyShapeInference_1.inferShapeFromJsonLiteral)(thing, resolver));
+        }
         // The type of the assign markup is the type of the right hand side.
         // {% assign x = y.property | filter1 | filter2 %}
         case liquid_html_parser_1.NodeTypes.AssignMarkup: {
@@ -996,6 +972,34 @@ function shapeToType(shape) {
     }
     return exports.Untyped;
 }
+/**
+ * Convert a resolved type back to a PropertyShape (inverse of shapeToType).
+ * Used when embedding resolved variable types into JSON literal shapes.
+ */
+function resolvedTypeToShape(type) {
+    if (typeof type === 'string') {
+        switch (type) {
+            case 'string':
+                return { kind: 'primitive', primitiveType: 'string' };
+            case 'number':
+                return { kind: 'primitive', primitiveType: 'number' };
+            case 'boolean':
+                return { kind: 'primitive', primitiveType: 'boolean' };
+            case exports.Untyped:
+            case exports.Unknown:
+                return undefined;
+            default:
+                return { kind: 'primitive' };
+        }
+    }
+    if (isShapeType(type))
+        return type.shape;
+    if (isArrayType(type)) {
+        const itemShape = resolvedTypeToShape(type.valueType);
+        return { kind: 'array', itemShape };
+    }
+    return undefined;
+}
 function inferPseudoTypePropertyType(curr, // settings
 lookup, objectMap) {
     const parentEntry = objectMap[curr];
@@ -1239,6 +1243,25 @@ function typeToDisplayString(type) {
         return type.types.map((t) => typeToDisplayString(t)).join(' | ');
     return 'unknown';
 }
+/**
+ * Extract the lookup path from assign lookups.
+ * For {% assign a["key1"]["key2"] = value %}, returns ['key1', 'key2']
+ */
+function getAssignLookupPath(lookups) {
+    const path = [];
+    for (const lookup of lookups) {
+        if (lookup.type === liquid_html_parser_1.NodeTypes.String) {
+            path.push(lookup.value);
+        }
+        else if (lookup.type === liquid_html_parser_1.NodeTypes.Number) {
+            path.push(`${lookup.value}`);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return path.length > 0 ? path : undefined;
+}
 /**
  * Extract the lookup path from a hash_assign target.
  * For {% hash_assign a['key1']['key2'] = value %}, returns ['key1', 'key2']
@@ -1301,181 +1324,4 @@ function findLastApplicableShape(shapes, position) {
     }
     return result;
 }
-function settingReturnType(setting) {
-    switch (setting.type) {
-        // basic settings
-        case 'checkbox':
-            return [{ type: 'boolean', name: '' }];
-        case 'range':
-        case 'number':
-            return [{ type: 'number', name: '' }];
-        case 'radio':
-        case 'select':
-        case 'text':
-        case 'textarea':
-            return [{ type: 'string', name: '' }];
-        // specialized settings
-        case 'article':
-            return [{ type: 'article', name: '' }];
-        case 'blog':
-            return [{ type: 'blog', name: '' }];
-        case 'collection':
-            return [{ type: 'collection', name: '' }];
-        case 'collection_list':
-            return [{ type: 'array', array_value: 'collection' }];
-        case 'color':
-            return [{ type: 'color', name: '' }];
-        case 'color_background':
-            return [{ type: 'string', name: '' }];
-        case 'color_scheme':
-            return [{ type: 'color_scheme', name: '' }];
-        // TODO ??
-        case 'color_scheme_group':
-            return [];
-        case 'font_picker':
-            return [{ type: 'font', name: '' }];
-        case 'html':
-            return [{ type: 'string', name: '' }];
-        case 'image_picker':
-            return [{ type: 'image', name: '' }];
-        case 'inline_richtext':
-            return [{ type: 'string', name: '' }];
-        case 'link_list':
-            return [{ type: 'linklist', name: '' }];
-        case 'liquid':
-            return [{ type: 'string', name: '' }];
-        case 'page':
-            return [{ type: 'page', name: '' }];
-        case 'product':
-            return [{ type: 'product', name: '' }];
-        case 'product_list':
-            return [{ type: 'array', array_value: 'product' }];
-        case 'richtext':
-            return [{ type: 'string', name: '' }];
-        case 'text_alignment':
-            return [{ type: 'string', name: '' }];
-        case 'url':
-            return [{ type: 'string', name: '' }];
-        case 'video':
-            return [{ type: 'video', name: '' }];
-        case 'video_url':
-            return [{ type: 'string', name: '' }];
-        default:
-            return [];
-    }
-}
-const METAFIELD_TYPE_TO_TYPE = Object.freeze({
-    single_line_text_field: String,
-    multi_line_text_field: String,
-    url_reference: String,
-    date: String,
-    date_time: String,
-    number_integer: 'number',
-    number_decimal: 'number',
-    product_reference: 'product',
-    collection_reference: 'collection',
-    variant_reference: 'variant',
-    page_reference: 'page',
-    boolean: 'boolean',
-    color: 'color',
-    weight: 'measurement',
-    volume: 'measurement',
-    dimension: 'measurement',
-    rating: 'rating',
-    money: 'money',
-    json: exports.Untyped,
-    metaobject_reference: 'metaobject',
-    mixed_reference: exports.Untyped,
-    rich_text_field: exports.Untyped,
-    file_reference: exports.Untyped,
-});
-const REFERENCE_TYPE_METAFIELDS = Object.entries(METAFIELD_TYPE_TO_TYPE)
-    .filter(([metafieldType, _type]) => metafieldType.endsWith('_reference'))
-    .map(([_metafieldType, type]) => type);
-function metafieldReturnType(metafieldType) {
-    let isArray = metafieldType.startsWith('list.');
-    if (isArray) {
-        metafieldType = metafieldType.split('.')[1];
-    }
-    let type = 'metafield_' + (METAFIELD_TYPE_TO_TYPE[metafieldType] ?? exports.Untyped);
-    if (isArray) {
-        return [{ type: `${type}_array`, name: '' }];
-    }
-    return [{ type: type, name: '' }];
-}
-// The default `metafield` type has an untyped `value` property.
-// We need to create new metafield types with the labels `metafield_x` and `metafield_x_array`
-// where x is the type of metafield inside the `value` property. The metafields ending with `x_array`
-// is where the value is an array of type x.
-const customMetafieldTypeEntries = (0, utils_1.memo)((baseMetafieldEntry) => {
-    if (!baseMetafieldEntry)
-        return {};
-    return [
-        ...new Set([...Object.values(METAFIELD_TYPE_TO_TYPE), ...platformos_check_common_1.FETCHED_METAFIELD_CATEGORIES]),
-    ].reduce((map, type) => {
-        {
-            const metafieldEntry = JSON.parse(JSON.stringify(baseMetafieldEntry)); // easy deep clone
-            const metafieldValueProp = metafieldEntry.properties?.find((prop) => prop.name === 'value');
-            if (metafieldValueProp) {
-                metafieldValueProp.return_type = [{ type: type, name: '' }];
-                metafieldValueProp.description = '';
-                metafieldEntry.name = `metafield_${type}`;
-                map[metafieldEntry.name] = metafieldEntry;
-            }
-        }
-        {
-            const metafieldArrayEntry = JSON.parse(JSON.stringify(baseMetafieldEntry)); // easy deep clone
-            const metafieldArrayValueProp = metafieldArrayEntry.properties?.find((prop) => prop.name === 'value');
-            if (metafieldArrayValueProp) {
-                // A metafield definition using a list of references does not use an array, but a separate type of collection.
-                // For auto-completion purposes, we can't use the array type
-                // https://shopify.dev/docs/api/liquid/objects/metafield#metafield-determining-the-length-of-a-list-metafield
-                if (REFERENCE_TYPE_METAFIELDS.includes(type)) {
-                    metafieldArrayValueProp.return_type = [{ type: 'untyped', name: '' }];
-                }
-                else {
-                    metafieldArrayValueProp.return_type = [{ type: 'array', name: '', array_value: type }];
-                }
-                metafieldArrayValueProp.description = '';
-                metafieldArrayEntry.name = `metafield_${type}_array`;
-                map[metafieldArrayEntry.name] = metafieldArrayEntry;
-            }
-        }
-        return map;
-    }, {});
-});
-function schemaSettingsAsProperties(ast) {
-    if (ast.type !== liquid_html_parser_1.NodeTypes.Document)
-        return [];
-    try {
-        const source = ast._source; // (the unfixed source)
-        const start = /\{%\s*schema\s*%\}/m.exec(source);
-        const end = /\{%\s*endschema\s*%\}/m.exec(source);
-        if (!start || !end)
-            return [];
-        const schema = source.slice(start.index + start[0].length, end.index);
-        const json = (0, platformos_check_common_1.parseJSON)(schema);
-        if ((0, platformos_check_common_1.isError)(json) || !('settings' in json) || !Array.isArray(json.settings))
-            return [];
-        const result = [];
-        const inputSettings = json.settings.filter(settings_1.isInputSetting);
-        for (const setting of inputSettings) {
-            result.push({
-                name: setting.id,
-                summary: '', // TODO, this should lookup the locale file for settings... setting.label
-                description: '', // TODO , this should lookup the locale file as well... setting.info,
-                return_type: settingReturnType(setting),
-                access: {
-                    global: false,
-                    parents: [],
-                    template: [],
-                },
-            });
-        }
-        return result;
-    }
-    catch (_) {
-        return [];
-    }
-}
 //# sourceMappingURL=TypeSystem.js.map