@platformos/platformos-language-server-common 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformos/platformos-language-server-common",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "platformOS",
@@ -27,9 +27,9 @@
     "type-check": "tsc --noEmit -p ./tsconfig.json"
   },
   "dependencies": {
-    "@platformos/liquid-html-parser": "^0.0.15",
-    "@platformos/platformos-check-common": "0.0.17",
-    "@platformos/platformos-graph": "0.0.17",
+    "@platformos/liquid-html-parser": "^0.0.17",
+    "@platformos/platformos-check-common": "0.0.19",
+    "@platformos/platformos-graph": "0.0.19",
     "@vscode/web-custom-data": "^0.4.6",
     "graphql": "^16.12.0",
     "graphql-language-service": "^5.2.2",

package/src/TypeSystem.spec.ts

@@ -882,8 +882,8 @@ query {
       }
     });
 
-    it('should support explicit push form (assign a = source << value)', async () => {
-      const ast = toLiquidHtmlAST(`{% assign arr = [] %}{% assign arr = arr << "item" %}{{ arr }}`);
+    it('should support bare push form (assign arr << value)', async () => {
+      const ast = toLiquidHtmlAST(`{% assign arr = [] %}{% assign arr << "item" %}{{ arr }}`);
       const variableOutput = ast.children[2];
       assert(isLiquidVariableOutput(variableOutput));
       const inferredType = await typeSystem.inferType(

package/src/TypeSystem.ts

@@ -1,6 +1,5 @@
 import {
   AssignMarkup,
-  AssignPushRhs,
   ComplexLiquidExpression,
   FunctionMarkup,
   LiquidDocParamNode,
@@ -382,14 +381,9 @@ async function buildSymbolsTable(
     // {% assign x = {a: 1, b: "hello"} %}
     // {% assign x["key"] = value %}
     // {% assign arr << item %}
-    // {% assign arr = source << item %}
     async AssignMarkup(node) {
-      // For explicit push form (assign a = source << value), treat as array append
-      const isPushRhs = node.value.type === NodeTypes.AssignPushRhs;
-      const effectiveValue = isPushRhs
-        ? (node.value as AssignPushRhs).pushValue
-        : (node.value as LiquidVariable);
-      const effectiveOperator = isPushRhs ? '<<' : node.operator;
+      const effectiveValue = node.value as LiquidVariable;
+      const effectiveOperator = node.operator;
       const expression = effectiveValue.expression;
       let valueShape: PropertyShape | undefined;
 
@@ -970,9 +964,7 @@ function inferType(
     // The type of the assign markup is the type of the right hand side.
     // {% assign x = y.property | filter1 | filter2 %}
     case NodeTypes.AssignMarkup: {
-      const assignValue =
-        thing.value.type === NodeTypes.AssignPushRhs ? thing.value.pushValue : thing.value;
-      return inferType(assignValue, symbolsTable, objectMap, filtersMap);
+      return inferType(thing.value, symbolsTable, objectMap, filtersMap);
     }
 
     // A variable lookup is expression[.lookup]*

package/src/completions/CompletionsProvider.ts

@@ -3,8 +3,13 @@ import {
   SourceCodeType,
   PlatformOSDocset,
 } from '@platformos/platformos-check-common';
-import type { AbstractFileSystem, DocumentsLocator } from '@platformos/platformos-common';
+import {
+  type AbstractFileSystem,
+  type DocumentsLocator,
+  FileType,
+} from '@platformos/platformos-common';
 import { CompletionItem, CompletionParams } from 'vscode-languageserver';
+import { URI, Utils } from 'vscode-uri';
 import { TypeSystem } from '../TypeSystem';
 import { DocumentManager } from '../documents';
 import { FindAppRootURI } from '../internal-types';
@@ -25,6 +30,9 @@ import {
   PartialCompletionProvider,
   RenderPartialParameterCompletionProvider,
   TranslationCompletionProvider,
+  FrontmatterKeyCompletionProvider,
+  GetLayoutNamesForURI,
+  GetAuthPolicyNamesForURI,
 } from './providers';
 import { GetPartialNamesForURI } from './providers/PartialCompletionProvider';
 import { GraphQLFieldCompletionProvider } from './providers/GraphQLFieldCompletionProvider';
@@ -35,7 +43,7 @@ export interface CompletionProviderDependencies {
   getTranslationsForURI?: GetTranslationsForURI;
   getPartialNamesForURI?: GetPartialNamesForURI;
   getDocDefinitionForURI?: GetDocDefinitionForURI;
-  /** File system for reading GraphQL files */
+  /** File system for reading GraphQL files and listing frontmatter-referenced files */
   fs?: AbstractFileSystem;
   /** Locator for finding documents by type */
   documentsLocator?: DocumentsLocator;
@@ -44,6 +52,10 @@ export interface CompletionProviderDependencies {
   log?: (message: string) => void;
   /** Callback to notify when unable to infer properties for a variable */
   notifyUnableToInferProperties?: (variableName: string) => void;
+  /** Override for listing available layout names (used in frontmatter value completions) */
+  getLayoutNamesForURI?: GetLayoutNamesForURI;
+  /** Override for listing available authorization policy names */
+  getAuthPolicyNamesForURI?: GetAuthPolicyNamesForURI;
 }
 
 export class CompletionsProvider {
@@ -63,6 +75,8 @@ export class CompletionsProvider {
     documentsLocator,
     findAppRootURI,
     log = () => {},
+    getLayoutNamesForURI,
+    getAuthPolicyNamesForURI,
   }: CompletionProviderDependencies) {
     this.documentManager = documentManager;
     this.platformosDocset = platformosDocset;
@@ -73,6 +87,27 @@ export class CompletionsProvider {
       documentManager,
     );
 
+    // Build layout/policy name callbacks from fs+findAppRootURI when not explicitly provided
+    let layoutNames: GetLayoutNamesForURI | undefined = getLayoutNamesForURI;
+    let authPolicyNames: GetAuthPolicyNamesForURI | undefined = getAuthPolicyNamesForURI;
+
+    if (fs && findAppRootURI) {
+      if (!layoutNames) {
+        layoutNames = async (uri: string) => {
+          const rootUri = await findAppRootURI(uri);
+          if (!rootUri) return [];
+          return listLayoutNames(fs, URI.parse(rootUri));
+        };
+      }
+      if (!authPolicyNames) {
+        authPolicyNames = async (uri: string) => {
+          const rootUri = await findAppRootURI(uri);
+          if (!rootUri) return [];
+          return listAuthPolicyNames(fs, URI.parse(rootUri));
+        };
+      }
+    }
+
     this.providers = [
       new HtmlTagCompletionProvider(),
       new HtmlAttributeCompletionProvider(documentManager),
@@ -87,6 +122,7 @@ export class CompletionsProvider {
       new FilterNamedParameterCompletionProvider(platformosDocset),
       new LiquidDocTagCompletionProvider(),
       new LiquidDocParamTypeCompletionProvider(platformosDocset),
+      new FrontmatterKeyCompletionProvider(layoutNames, authPolicyNames),
     ];
   }
 
@@ -116,3 +152,85 @@ export class CompletionsProvider {
     }
   }
 }
+
+// ── File listing helpers ─────────────────────────────────────────────────────
+
+/** Recursively list .liquid files under a URI directory. Returns full URI strings. */
+async function listLiquidFilesRecursively(fs: AbstractFileSystem, dirUri: URI): Promise<string[]> {
+  let entries: [string, FileType][];
+  try {
+    entries = await fs.readDirectory(dirUri.toString());
+  } catch {
+    return [];
+  }
+
+  const results: string[] = [];
+  for (const [entryUri, entryType] of entries) {
+    if (entryType === FileType.Directory) {
+      const sub = await listLiquidFilesRecursively(fs, URI.parse(entryUri));
+      results.push(...sub);
+    } else if (entryType === FileType.File && entryUri.endsWith('.liquid')) {
+      results.push(entryUri);
+    }
+  }
+  return results;
+}
+
+async function listLayoutNames(fs: AbstractFileSystem, root: URI): Promise<string[]> {
+  const names: string[] = [];
+
+  // App layouts: app/views/layouts/**/*.liquid
+  const appLayoutsDir = Utils.joinPath(root, 'app', 'views', 'layouts');
+  const appBase = appLayoutsDir.toString() + '/';
+  for (const uri of await listLiquidFilesRecursively(fs, appLayoutsDir)) {
+    const rel = uri.startsWith(appBase) ? uri.slice(appBase.length) : uri;
+    names.push(rel.replace(/\.liquid$/, ''));
+  }
+
+  // Module layouts from both modules/ and app/modules/ (overwrites).
+  // Both are reported as modules/{mod}/{rest} — the Set below deduplicates them.
+  for (const modulesRoot of ['modules', 'app/modules'] as const) {
+    let moduleEntries: [string, FileType][] = [];
+    try {
+      moduleEntries = await fs.readDirectory(Utils.joinPath(root, modulesRoot).toString());
+    } catch {
+      /* directory does not exist */
+    }
+
+    for (const [modDirUri, modType] of moduleEntries) {
+      if (modType !== FileType.Directory) continue;
+      const modName = modDirUri.replace(/\/$/, '').split('/').at(-1)!;
+      for (const visibility of ['public', 'private'] as const) {
+        const layoutsDir = Utils.joinPath(URI.parse(modDirUri), visibility, 'views', 'layouts');
+        const base = layoutsDir.toString() + '/';
+        for (const uri of await listLiquidFilesRecursively(fs, layoutsDir)) {
+          const rest = uri.startsWith(base) ? uri.slice(base.length) : uri;
+          names.push(`modules/${modName}/${rest.replace(/\.liquid$/, '')}`);
+        }
+      }
+    }
+  }
+
+  return [...new Set(names)].sort();
+}
+
+async function listAuthPolicyNames(fs: AbstractFileSystem, root: URI): Promise<string[]> {
+  const dir = Utils.joinPath(root, 'app', 'authorization_policies');
+  let entries: [string, FileType][] = [];
+  try {
+    entries = await fs.readDirectory(dir.toString());
+  } catch {
+    return [];
+  }
+
+  return entries
+    .filter(([uri, type]) => type === FileType.File && uri.endsWith('.liquid'))
+    .map(([uri]) =>
+      uri
+        .replace(/\/$/, '')
+        .split('/')
+        .at(-1)!
+        .replace(/\.liquid$/, ''),
+    )
+    .sort();
+}

package/src/completions/params/LiquidCompletionParams.ts

@@ -447,8 +447,7 @@ function findCurrentNode(
       case NodeTypes.ExportMarkup:
       case NodeTypes.RedirectToMarkup:
       case NodeTypes.IncludeFormMarkup:
-      case NodeTypes.SpamProtectionMarkup:
-      case NodeTypes.AssignPushRhs: {
+      case NodeTypes.SpamProtectionMarkup: {
         break;
       }
 

package/src/completions/providers/FrontmatterKeyCompletionProvider.spec.ts

@@ -0,0 +1,196 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { CompletionsProvider } from '../CompletionsProvider';
+import { DocumentManager } from '../../documents';
+
+const mockDocset = {
+  graphQL: async () => null,
+  filters: async () => [],
+  objects: async () => [],
+  liquidDrops: async () => [],
+  tags: async () => [],
+};
+
+describe('Module: FrontmatterKeyCompletionProvider', async () => {
+  let provider: CompletionsProvider;
+
+  beforeEach(async () => {
+    provider = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      platformosDocset: mockDocset,
+    });
+  });
+
+  it('completes a key from a prefix inside page frontmatter', async () => {
+    // "slu" prefix matches only "slug" in the Page schema
+    await expect(provider).to.complete(
+      {
+        source: `---\nslu█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      ['slug'],
+    );
+  });
+
+  it('completes a key from a prefix inside form_configurations frontmatter', async () => {
+    // "nam" prefix matches only "name" in the FormConfiguration schema
+    await expect(provider).to.complete(
+      {
+        source: `---\nnam█\n---\n`,
+        relativePath: 'app/form_configurations/test.liquid',
+      },
+      ['name'],
+    );
+  });
+
+  it('does not complete in value position for fields without enum values', async () => {
+    // "slug" has no enumValues — value position should return nothing
+    await expect(provider).to.complete(
+      {
+        source: `---\nslug: █\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      [],
+    );
+  });
+
+  it('completes enum values for the method field', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nmethod: █\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      expect.arrayContaining([
+        { label: 'get', kind: 12 },
+        { label: 'post', kind: 12 },
+      ]),
+    );
+  });
+
+  it('filters enum completions by prefix', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nmethod: po█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      ['post'],
+    );
+  });
+
+  it('completes layout names when getLayoutNamesForURI is provided', async () => {
+    const providerWithLayouts = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      platformosDocset: mockDocset,
+      getLayoutNamesForURI: async () => ['application', 'auth', 'modules/community/base'],
+    });
+    await expect(providerWithLayouts).to.complete(
+      {
+        source: `---\nlayout: app█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      ['application'],
+    );
+  });
+
+  it('includes app/modules overwrite layouts alongside module layouts in completions', async () => {
+    // When both app/modules/community/public/views/layouts/base.liquid (overwrite) and
+    // the original modules/community/public/views/layouts/base.liquid are present,
+    // both appear as 'modules/community/base' and Set deduplication yields a single entry.
+    const providerWithLayouts = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      platformosDocset: mockDocset,
+      getLayoutNamesForURI: async () => ['modules/community/base'],
+    });
+    await expect(providerWithLayouts).to.complete(
+      {
+        source: `---\nlayout: modules/█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      ['modules/community/base'],
+    );
+  });
+
+  it('filters module layout names by modules/ prefix', async () => {
+    const providerWithLayouts = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      platformosDocset: mockDocset,
+      getLayoutNamesForURI: async () => ['application', 'auth', 'modules/community/base'],
+    });
+    await expect(providerWithLayouts).to.complete(
+      {
+        source: `---\nlayout: modules/█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      ['modules/community/base'],
+    );
+  });
+
+  it('returns no layout completions when getLayoutNamesForURI is not configured', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nlayout: █\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      [],
+    );
+  });
+
+  it('completes auth policy list items when getAuthPolicyNamesForURI is provided', async () => {
+    const providerWithPolicies = new CompletionsProvider({
+      documentManager: new DocumentManager(),
+      platformosDocset: mockDocset,
+      getAuthPolicyNamesForURI: async () => ['is_authenticated', 'is_admin'],
+    });
+    await expect(providerWithPolicies).to.complete(
+      {
+        source: `---\nauthorization_policies:\n  - is_a█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      expect.arrayContaining([{ label: 'is_admin', kind: 12 }]),
+    );
+  });
+
+  it('completes enum values for the request_type field on ApiCall', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nrequest_type: █\n---\n`,
+        relativePath: 'app/notifications/api_call_notifications/test.liquid',
+      },
+      expect.arrayContaining([
+        { label: 'GET', kind: 12 },
+        { label: 'POST', kind: 12 },
+        { label: 'DELETE', kind: 12 },
+      ]),
+    );
+  });
+
+  it('does not complete outside the frontmatter', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nslug: /home\n---\n{{ █ }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      [],
+    );
+  });
+
+  it('does not complete for files with no known schema', async () => {
+    await expect(provider).to.complete(
+      {
+        source: `---\nslu█\n---\n{{ content }}`,
+        relativePath: 'some/random/path/file.liquid',
+      },
+      [],
+    );
+  });
+
+  it('excludes already-used keys from completions', async () => {
+    // slug is already present — "slu" prefix should return nothing
+    await expect(provider).to.complete(
+      {
+        source: `---\nslug: /home\nslu█\n---\n{{ content }}`,
+        relativePath: 'app/views/pages/test.html.liquid',
+      },
+      [],
+    );
+  });
+});

package/src/completions/providers/FrontmatterKeyCompletionProvider.ts

@@ -0,0 +1,182 @@
+import { NodeTypes, YAMLFrontmatter } from '@platformos/liquid-html-parser';
+import { getFrontmatterSchema, getFileType } from '@platformos/platformos-common';
+import { CompletionItem, CompletionItemKind } from 'vscode-languageserver';
+import { LiquidCompletionParams } from '../params';
+import { Provider } from './common';
+
+export type GetLayoutNamesForURI = (uri: string) => Promise<string[]>;
+export type GetAuthPolicyNamesForURI = (uri: string) => Promise<string[]>;
+
+export class FrontmatterKeyCompletionProvider implements Provider {
+  constructor(
+    private readonly getLayoutNamesForURI?: GetLayoutNamesForURI,
+    private readonly getAuthPolicyNamesForURI?: GetAuthPolicyNamesForURI,
+  ) {}
+
+  async completions(params: LiquidCompletionParams): Promise<CompletionItem[]> {
+    const { document } = params;
+
+    // Use the full document AST — the partial AST used for other completions is truncated
+    // at the cursor, so the frontmatter closing "---" is never present there.
+    const ast = document.ast;
+    if (ast instanceof Error || ast.type !== NodeTypes.Document) return [];
+
+    const frontmatterNode = ast.children.find(
+      (child): child is YAMLFrontmatter => child.type === NodeTypes.YAMLFrontmatter,
+    );
+    if (!frontmatterNode) return [];
+
+    const schema = getFrontmatterSchema(getFileType(params.textDocument.uri));
+    if (!schema) return [];
+
+    // Locate the YAML body within the source: skip the opening "---\n"
+    const source = document.textDocument.getText();
+    const bodyStart = source.indexOf('\n', frontmatterNode.position.start) + 1;
+    const bodyEnd = bodyStart + frontmatterNode.body.length;
+
+    const cursor = document.textDocument.offsetAt(params.position);
+    if (cursor < bodyStart || cursor > bodyEnd) return [];
+
+    const cursorInBody = cursor - bodyStart;
+
+    // Determine what context the cursor is in based on the current line text.
+    const bodyUpToCursor = frontmatterNode.body.slice(0, cursorInBody);
+    const lastNewline = bodyUpToCursor.lastIndexOf('\n');
+    const currentLineText = bodyUpToCursor.slice(lastNewline + 1);
+
+    // ── List-item completion ─────────────────────────────────────────────────
+    // Must be checked before colonIndex since list items have no colon.
+    const listItemMatch = currentLineText.match(/^(\s*)-\s*(.*)/);
+    if (listItemMatch) {
+      const partial = listItemMatch[2];
+      const parentKey = findParentKey(bodyUpToCursor);
+      return this.listItemCompletions(parentKey, partial, params.textDocument.uri);
+    }
+
+    const colonIndex = currentLineText.indexOf(':');
+
+    if (colonIndex === -1) {
+      // ── Key completion ────────────────────────────────────────────────────
+      return this.keyCompletions(frontmatterNode.body, currentLineText, schema);
+    }
+
+    // ── Scalar value completion ───────────────────────────────────────────────
+    const key = currentLineText.slice(0, colonIndex).trim();
+    const afterColon = currentLineText.slice(colonIndex + 1);
+    const rawPartial = afterColon.trimStart();
+    // Strip enclosing quotes for prefix matching, but keep raw text for filtering
+    const partial = rawPartial.replace(/^['"]/, '').replace(/['"]$/, '');
+
+    return this.valueCompletions(key, partial, schema, params.textDocument.uri);
+  }
+
+  // ── Key completions ─────────────────────────────────────────────────────────
+
+  private keyCompletions(
+    body: string,
+    currentLineText: string,
+    schema: ReturnType<typeof getFrontmatterSchema>,
+  ): CompletionItem[] {
+    if (!schema) return [];
+    const partial = currentLineText.trimStart();
+
+    // Collect keys already present so we can omit them.
+    const usedKeys = new Set<string>();
+    const keyRegex = /^([a-zA-Z_][a-zA-Z0-9_]*):/gm;
+    let match: RegExpExecArray | null;
+    while ((match = keyRegex.exec(body)) !== null) {
+      usedKeys.add(match[1]);
+    }
+
+    return Object.entries(schema.fields)
+      .filter(([key]) => !usedKeys.has(key) && key.startsWith(partial))
+      .map(([key, fieldSchema]): CompletionItem => {
+        const typeStr = Array.isArray(fieldSchema.type)
+          ? fieldSchema.type.join(' | ')
+          : fieldSchema.type;
+        const tags = [
+          fieldSchema.required ? 'required' : undefined,
+          fieldSchema.deprecated ? 'deprecated' : undefined,
+        ].filter(Boolean);
+        const detail = tags.length > 0 ? `${typeStr} (${tags.join(', ')})` : typeStr;
+
+        return {
+          label: key,
+          kind: CompletionItemKind.Field,
+          detail,
+          documentation: fieldSchema.description
+            ? { kind: 'markdown', value: fieldSchema.description }
+            : undefined,
+          insertText: key + ': ',
+        };
+      });
+  }
+
+  // ── Value completions for scalar fields ─────────────────────────────────────
+
+  private async valueCompletions(
+    key: string,
+    partial: string,
+    schema: ReturnType<typeof getFrontmatterSchema>,
+    uri: string,
+  ): Promise<CompletionItem[]> {
+    if (!schema) return [];
+
+    // Layout field — list available layout files
+    if (key === 'layout' || key === 'layout_name') {
+      const names = (await this.getLayoutNamesForURI?.(uri)) ?? [];
+      return names
+        .filter((n) => n.startsWith(partial))
+        .map((n) => ({ label: n, kind: CompletionItemKind.Value }));
+    }
+
+    // Fields with enum values
+    const fieldSchema = schema.fields[key];
+    if (fieldSchema?.enumValues) {
+      return fieldSchema.enumValues
+        .map(String)
+        .filter((v) => v.startsWith(partial))
+        .map((v) => ({
+          label: v,
+          kind: CompletionItemKind.Value,
+        }));
+    }
+
+    return [];
+  }
+
+  // ── List-item completions (authorization_policies, etc.) ─────────────────────
+
+  private async listItemCompletions(
+    parentKey: string | undefined,
+    partial: string,
+    uri: string,
+  ): Promise<CompletionItem[]> {
+    if (parentKey === 'authorization_policies') {
+      const names = (await this.getAuthPolicyNamesForURI?.(uri)) ?? [];
+      return names
+        .filter((n) => n.startsWith(partial))
+        .map((n) => ({ label: n, kind: CompletionItemKind.Value }));
+    }
+    return [];
+  }
+}
+
+/** Walk backwards through the YAML body up-to-cursor to find the key that
+ *  owns the current list block (the first non-indented, non-list-item line). */
+function findParentKey(bodyUpToCursor: string): string | undefined {
+  const lines = bodyUpToCursor.split('\n');
+  // Start from the second-to-last line (the current line is the last)
+  for (let i = lines.length - 2; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.trim()) continue; // skip blank lines
+    // List item line — keep walking up
+    if (/^\s+-/.test(line)) continue;
+    // Top-level key line
+    const match = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*):/);
+    if (match) return match[1];
+    // Anything else — stop
+    break;
+  }
+  return undefined;
+}

package/src/completions/providers/index.ts

@@ -14,4 +14,9 @@ export {
 } from './RenderPartialParameterCompletionProvider';
 export { LiquidDocTagCompletionProvider } from './LiquidDocTagCompletionProvider';
 export { LiquidDocParamTypeCompletionProvider } from './LiquidDocParamTypeCompletionProvider';
+export {
+  FrontmatterKeyCompletionProvider,
+  GetLayoutNamesForURI,
+  GetAuthPolicyNamesForURI,
+} from './FrontmatterKeyCompletionProvider';
 export { Provider } from './common/Provider';

package/src/definitions/DefinitionProvider.ts

@@ -5,6 +5,7 @@ import { DefinitionLink, DefinitionParams } from 'vscode-languageserver';
 import { AugmentedJsonSourceCode, DocumentManager } from '../documents';
 import { SearchPathsLoader } from '../utils/searchPaths';
 import { BaseDefinitionProvider } from './BaseDefinitionProvider';
+import { FrontmatterDefinitionProvider } from './providers/FrontmatterDefinitionProvider';
 import { PageRouteDefinitionProvider } from './providers/PageRouteDefinitionProvider';
 import { RenderPartialDefinitionProvider } from './providers/RenderPartialDefinitionProvider';
 import { TranslationStringDefinitionProvider } from './providers/TranslationStringDefinitionProvider';
@@ -28,6 +29,7 @@ export class DefinitionProvider {
     if (fs && findAppRootURI) {
       this.pageRouteProvider = new PageRouteDefinitionProvider(documentManager, fs, findAppRootURI);
       this.providers.push(this.pageRouteProvider);
+      this.providers.push(new FrontmatterDefinitionProvider(documentManager, fs, findAppRootURI));
 
       if (documentsLocator && searchPathsCache) {
         this.providers.push(