@platformos/platformos-language-server-common 0.0.2

package/dist/utils/uri.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTemplate = exports.templateName = exports.isSectionGroup = exports.sectionGroupName = exports.isSection = exports.sectionName = exports.isBlock = exports.blockName = exports.isAsset = exports.assetName = exports.isPartial = exports.partialName = void 0;
+const platformos_check_common_1 = require("@platformos/platformos-check-common");
+const partialName = (uri) => platformos_check_common_1.path.basename(uri, '.liquid');
+exports.partialName = partialName;
+const isPartial = (uri) => /\b(partials|lib)(\\|\/)[^\\\/]*\.liquid/.test(uri);
+exports.isPartial = isPartial;
+// asset urls have their `.liquid`` removed (if present) and require the other extension */
+const assetName = (uri) => platformos_check_common_1.path.basename(uri, '.liquid');
+exports.assetName = assetName;
+const isAsset = (uri) => /\bassets(\\|\/)[^\\\/]/.test(uri);
+exports.isAsset = isAsset;
+const blockName = (uri) => platformos_check_common_1.path.basename(uri, '.liquid');
+exports.blockName = blockName;
+const isBlock = (uri) => /\bblocks(\\|\/)[^\\\/]/.test(uri);
+exports.isBlock = isBlock;
+const sectionName = (uri) => platformos_check_common_1.path.basename(uri, '.liquid');
+exports.sectionName = sectionName;
+const isSection = (uri) => /\bsections(\\|\/)[^\\\/]/.test(uri) && /.liquid$/.test(uri);
+exports.isSection = isSection;
+const sectionGroupName = (uri) => platformos_check_common_1.path.basename(uri, '.json');
+exports.sectionGroupName = sectionGroupName;
+const isSectionGroup = (uri) => /\bsections(\\|\/)[^\\\/]/.test(uri) && /.json$/.test(uri);
+exports.isSectionGroup = isSectionGroup;
+const templateName = (uri) => platformos_check_common_1.path.basename(uri, '.json');
+exports.templateName = templateName;
+const isTemplate = (uri) => /\btemplates(\\|\/)[^\\\/]/.test(uri);
+exports.isTemplate = isTemplate;
+//# sourceMappingURL=uri.js.map

package/dist/utils/uri.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.js","sourceRoot":"","sources":["../../src/utils/uri.ts"],"names":[],"mappings":";;;AAAA,iFAA2D;AAEpD,MAAM,WAAW,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AAA7D,QAAA,WAAW,eAAkD;AACnE,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,yCAAyC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAAjF,QAAA,SAAS,aAAwE;AAE9F,2FAA2F;AACpF,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AAA3D,QAAA,SAAS,aAAkD;AACjE,MAAM,OAAO,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAA9D,QAAA,OAAO,WAAuD;AAEpE,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AAA3D,QAAA,SAAS,aAAkD;AACjE,MAAM,OAAO,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAA9D,QAAA,OAAO,WAAuD;AAEpE,MAAM,WAAW,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;AAA7D,QAAA,WAAW,eAAkD;AACnE,MAAM,SAAS,GAAG,CAAC,GAAW,EAAE,EAAE,CACvC,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AADlD,QAAA,SAAS,aACyC;AAExD,MAAM,gBAAgB,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAAhE,QAAA,gBAAgB,oBAAgD;AACtE,MAAM,cAAc,GAAG,CAAC,GAAW,EAAE,EAAE,CAC5C,0BAA0B,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AADhD,QAAA,cAAc,kBACkC;AAEtD,MAAM,YAAY,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,8BAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AAA5D,QAAA,YAAY,gBAAgD;AAClE,MAAM,UAAU,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,2BAA2B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAApE,QAAA,UAAU,cAA0D"}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION: string;

package/dist/version.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+const package_json_1 = __importDefault(require("../package.json"));
+exports.VERSION = package_json_1.default.version;
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":";;;;;;AAAA,mEAA0C;AAE7B,QAAA,OAAO,GAAW,sBAAW,CAAC,OAAO,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@platformos/platformos-language-server-common",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "platformOS",
+  "homepage": "https://github.com/Platform-OS/platformos-tools/tree/main/packages/platformos-language-server-common#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Platform-OS/platformos-tools.git",
+    "directory": "packages/platformos-language-server-common"
+  },
+  "bugs": {
+    "url": "https://github.com/Platform-OS/platformos-tools/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "@platformos:registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "yarn build:ts",
+    "build:ci": "yarn build",
+    "build:ts": "tsc -b ./tsconfig.build.json",
+    "dev": "tsc -b src --watch",
+    "test": "vitest",
+    "type-check": "tsc --noEmit -p ./tsconfig.json"
+  },
+  "dependencies": {
+    "@platformos/liquid-html-parser": "^0.0.2",
+    "@platformos/platformos-check-common": "0.0.2",
+    "@platformos/platformos-graph": "0.0.2",
+    "@vscode/web-custom-data": "^0.4.6",
+    "vscode-json-languageservice": "^5.3.10",
+    "vscode-languageserver": "^8.0.2",
+    "vscode-css-languageservice": "6.3.2",
+    "vscode-languageserver-textdocument": "^1.0.8",
+    "vscode-uri": "^3.0.7"
+  }
+}

package/src/ClientCapabilities.ts

@@ -0,0 +1,63 @@
+import {
+  ClientCapabilities as LanguageClientCapabilities,
+  InitializeParams,
+} from 'vscode-languageserver';
+
+export class ClientCapabilities {
+  private capabilities?: LanguageClientCapabilities = {};
+  private initializationOptions?: InitializeParams['initializationOptions'] = {};
+
+  setup(
+    capabilities: LanguageClientCapabilities,
+    initializationOptions: InitializeParams['initializationOptions'] = {},
+  ) {
+    this.capabilities = capabilities;
+    this.initializationOptions = initializationOptions;
+  }
+
+  get hasWorkspaceConfigurationSupport() {
+    return !!this.capabilities?.workspace?.configuration;
+  }
+
+  get hasApplyEditSupport() {
+    return !!this.capabilities?.workspace?.applyEdit;
+  }
+
+  get hasWorkspaceFoldersSupport() {
+    return !!this.capabilities?.workspace?.workspaceFolders;
+  }
+
+  get hasDidChangeConfigurationDynamicRegistrationSupport() {
+    return !!this.capabilities?.workspace?.didChangeConfiguration?.dynamicRegistration;
+  }
+
+  get hasDidChangeWatchedFilesDynamicRegistrationSupport() {
+    return !!this.capabilities?.workspace?.didChangeWatchedFiles?.dynamicRegistration;
+  }
+
+  get hasShowDocumentSupport() {
+    return !!this.capabilities?.window?.showDocument;
+  }
+
+  get hasProgressSupport() {
+    return !!this.capabilities?.window?.workDoneProgress;
+  }
+
+  initializationOption<T>(key: string, defaultValue: T): T {
+    // { 'themeCheck.checkOnSave': true }
+    const direct = this.initializationOptions?.[key];
+    if (direct !== undefined) return direct;
+
+    // { themeCheck: { checkOnSave: true } }
+    const nested = pathGet<T>(this.initializationOptions, key);
+    if (nested !== undefined) return nested;
+
+    // fallback
+    return defaultValue;
+  }
+}
+
+function pathGet<T>(obj: any, key: string): T | undefined {
+  const path = key.split('.');
+  return path.reduce((acc, subpath) => acc?.[subpath], obj);
+}

package/src/PropertyShapeInference.ts

@@ -0,0 +1,394 @@
+import { parse, SelectionSetNode, FieldNode } from 'graphql/language';
+import {
+  buildSchema,
+  GraphQLSchema,
+  GraphQLObjectType,
+  isListType,
+  isNonNullType,
+  isObjectType,
+  getNamedType,
+  GraphQLOutputType,
+} from 'graphql';
+import { parseJSON, isError } from '@platformos/platformos-check-common';
+
+export interface PropertyShape {
+  kind: 'object' | 'array' | 'primitive';
+  /** For objects: map of property name to nested shape */
+  properties?: Map<string, PropertyShape>;
+  /** For arrays: shape of array items */
+  itemShape?: PropertyShape;
+  /** For primitives: the primitive type */
+  primitiveType?: 'string' | 'number' | 'boolean' | 'null';
+}
+
+export interface LookupResult {
+  shape: PropertyShape | undefined;
+  error?: 'unknown_property' | 'primitive_access';
+  errorAt?: number;
+}
+
+/**
+ * Merge two shapes together, combining their properties
+ */
+function mergeShapes(a: PropertyShape, b: PropertyShape): PropertyShape {
+  // If same kind, merge appropriately
+  if (a.kind === 'object' && b.kind === 'object') {
+    const properties = new Map(a.properties);
+    if (b.properties) {
+      for (const [key, val] of b.properties) {
+        const existing = properties.get(key);
+        if (existing) {
+          properties.set(key, mergeShapes(existing, val));
+        } else {
+          properties.set(key, val);
+        }
+      }
+    }
+    return { kind: 'object', properties };
+  }
+  if (a.kind === 'array' && b.kind === 'array') {
+    const itemShape =
+      a.itemShape && b.itemShape
+        ? mergeShapes(a.itemShape, b.itemShape)
+        : a.itemShape || b.itemShape;
+    return { kind: 'array', itemShape };
+  }
+  // Different kinds or primitives - prefer the first
+  return a;
+}
+
+/**
+ * Infer shape from a parsed JSON value
+ */
+export function inferShapeFromJSON(value: unknown): PropertyShape {
+  if (value === null) {
+    return { kind: 'primitive', primitiveType: 'null' };
+  }
+  if (typeof value === 'string') {
+    return { kind: 'primitive', primitiveType: 'string' };
+  }
+  if (typeof value === 'number') {
+    return { kind: 'primitive', primitiveType: 'number' };
+  }
+  if (typeof value === 'boolean') {
+    return { kind: 'primitive', primitiveType: 'boolean' };
+  }
+  if (Array.isArray(value)) {
+    // Merge shapes from all array elements
+    let itemShape: PropertyShape | undefined;
+    for (const item of value) {
+      const shape = inferShapeFromJSON(item);
+      itemShape = itemShape ? mergeShapes(itemShape, shape) : shape;
+    }
+    return { kind: 'array', itemShape };
+  }
+  if (typeof value === 'object') {
+    const properties = new Map<string, PropertyShape>();
+    for (const [key, val] of Object.entries(value)) {
+      properties.set(key, inferShapeFromJSON(val));
+    }
+    return { kind: 'object', properties };
+  }
+  return { kind: 'primitive' };
+}
+
+/**
+ * Try to parse a string as JSON and infer its shape
+ */
+export function inferShapeFromJSONString(jsonString: string): PropertyShape | undefined {
+  const parsed = parseJSON(jsonString);
+  // parseJSON returns Error on strict mode failure, or undefined for invalid JSON
+  // We only want to infer shapes for valid JSON objects/arrays
+  if (isError(parsed) || parsed === undefined || parsed === null) {
+    return undefined;
+  }
+  // Only infer shapes for objects and arrays, not primitive JSON values
+  if (typeof parsed !== 'object') {
+    return undefined;
+  }
+  return inferShapeFromJSON(parsed);
+}
+
+/**
+ * Unwrap NonNull and get the underlying type
+ */
+function unwrapType(type: GraphQLOutputType): GraphQLOutputType {
+  if (isNonNullType(type)) {
+    return type.ofType;
+  }
+  return type;
+}
+
+/**
+ * Check if a type is a list (array) type
+ */
+function isArrayType(type: GraphQLOutputType): boolean {
+  const unwrapped = unwrapType(type);
+  return isListType(unwrapped);
+}
+
+/**
+ * Convert a GraphQL SelectionSet to a PropertyShape using schema for type info
+ */
+function selectionSetToShape(
+  selectionSet: SelectionSetNode,
+  parentType?: GraphQLObjectType,
+): PropertyShape {
+  const properties = new Map<string, PropertyShape>();
+
+  for (const selection of selectionSet.selections) {
+    if (selection.kind === 'Field') {
+      const field = selection as FieldNode;
+      const fieldName = (field.alias ?? field.name).value;
+      const schemaFieldName = field.name.value;
+
+      // Get field type from schema if available
+      const schemaField = parentType?.getFields()[schemaFieldName];
+      const fieldType = schemaField?.type;
+
+      if (field.selectionSet) {
+        // Nested object or array of objects
+        let nestedType: GraphQLObjectType | undefined;
+
+        if (fieldType) {
+          const namedType = getNamedType(fieldType);
+          if (isObjectType(namedType)) {
+            nestedType = namedType;
+          }
+        }
+
+        const nestedShape = selectionSetToShape(field.selectionSet, nestedType);
+
+        if (fieldType && isArrayType(fieldType)) {
+          properties.set(fieldName, { kind: 'array', itemShape: nestedShape });
+        } else {
+          properties.set(fieldName, nestedShape);
+        }
+      } else {
+        // Leaf field
+        if (fieldType && isArrayType(fieldType)) {
+          properties.set(fieldName, { kind: 'array', itemShape: { kind: 'primitive' } });
+        } else {
+          properties.set(fieldName, { kind: 'primitive' });
+        }
+      }
+    }
+  }
+
+  return { kind: 'object', properties };
+}
+
+/**
+ * Extract response shape from GraphQL document content
+ * @param content - The GraphQL query/mutation content
+ * @param schemaString - Optional GraphQL schema SDL string for accurate type inference
+ */
+export function inferShapeFromGraphQL(
+  content: string,
+  schemaString?: string,
+): PropertyShape | undefined {
+  try {
+    const document = parse(content);
+
+    let schema: GraphQLSchema | undefined;
+    let rootType: GraphQLObjectType | undefined;
+
+    if (schemaString) {
+      try {
+        schema = buildSchema(schemaString);
+      } catch {
+        // Schema parse error - continue without schema
+      }
+    }
+
+    for (const definition of document.definitions) {
+      if (definition.kind === 'OperationDefinition' && definition.selectionSet) {
+        if (schema) {
+          if (definition.operation === 'query') {
+            rootType = schema.getQueryType() ?? undefined;
+          } else if (definition.operation === 'mutation') {
+            rootType = schema.getMutationType() ?? undefined;
+          }
+        }
+
+        return selectionSetToShape(definition.selectionSet, rootType);
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Look up a property path in a shape, returning the shape at that path.
+ */
+export function lookupPropertyPath(shape: PropertyShape, path: string[]): LookupResult {
+  let current: PropertyShape = shape;
+
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+
+    if (current.kind === 'primitive') {
+      return { shape: undefined, error: 'primitive_access', errorAt: i };
+    }
+
+    if (current.kind === 'array') {
+      if (key === 'first' || key === 'last') {
+        if (!current.itemShape) {
+          return { shape: undefined, error: 'unknown_property', errorAt: i };
+        }
+        current = current.itemShape;
+        continue;
+      }
+      if (key === 'size') {
+        current = { kind: 'primitive', primitiveType: 'number' };
+        continue;
+      }
+      if (/^\d+$/.test(key)) {
+        if (!current.itemShape) {
+          return { shape: undefined, error: 'unknown_property', errorAt: i };
+        }
+        current = current.itemShape;
+        continue;
+      }
+      return { shape: undefined, error: 'unknown_property', errorAt: i };
+    }
+
+    if (current.kind === 'object') {
+      const prop = current.properties?.get(key);
+      if (prop) {
+        current = prop;
+        continue;
+      }
+
+      return { shape: undefined, error: 'unknown_property', errorAt: i };
+    }
+  }
+
+  return { shape: current };
+}
+
+/**
+ * Get available properties at a given shape (for autocomplete)
+ */
+export function getAvailableProperties(shape: PropertyShape): string[] {
+  if (shape.kind === 'object' && shape.properties) {
+    return Array.from(shape.properties.keys());
+  }
+  if (shape.kind === 'array') {
+    return ['first', 'last', 'size'];
+  }
+  if (shape.kind === 'primitive' && shape.primitiveType === 'string') {
+    return ['size'];
+  }
+  return [];
+}
+
+export interface PropertyWithType {
+  name: string;
+  type: string;
+  detail: string;
+}
+
+/**
+ * Convert a PropertyShape to a human-readable type string
+ */
+export function shapeToTypeString(shape: PropertyShape): string {
+  if (shape.kind === 'primitive') {
+    return shape.primitiveType ?? 'any';
+  }
+  if (shape.kind === 'array') {
+    if (shape.itemShape) {
+      return `${shapeToTypeString(shape.itemShape)}[]`;
+    }
+    return 'array';
+  }
+  if (shape.kind === 'object') {
+    return 'object';
+  }
+  return 'any';
+}
+
+const MAX_KEYS_TO_SHOW = 5;
+
+/**
+ * Convert a PropertyShape to a detailed multi-line description
+ */
+export function shapeToDetailString(shape: PropertyShape): string {
+  const typeStr = shapeToTypeString(shape);
+  const lines: string[] = [`Type: ${typeStr}`];
+
+  if (shape.kind === 'object' && shape.properties && shape.properties.size > 0) {
+    const keys = Array.from(shape.properties.keys());
+    if (keys.length <= MAX_KEYS_TO_SHOW) {
+      lines.push(`Keys: ${keys.join(', ')}`);
+    } else {
+      const shown = keys.slice(0, MAX_KEYS_TO_SHOW).join(', ');
+      lines.push(`Keys: ${shown}, ... (+${keys.length - MAX_KEYS_TO_SHOW} more)`);
+    }
+  }
+
+  if (shape.kind === 'array' && shape.itemShape) {
+    if (
+      shape.itemShape.kind === 'object' &&
+      shape.itemShape.properties &&
+      shape.itemShape.properties.size > 0
+    ) {
+      const keys = Array.from(shape.itemShape.properties.keys());
+      if (keys.length <= MAX_KEYS_TO_SHOW) {
+        lines.push(`Item keys: ${keys.join(', ')}`);
+      } else {
+        const shown = keys.slice(0, MAX_KEYS_TO_SHOW).join(', ');
+        lines.push(`Item keys: ${shown}, ... (+${keys.length - MAX_KEYS_TO_SHOW} more)`);
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Get available properties with their types at a given shape (for autocomplete)
+ */
+export function getAvailablePropertiesWithTypes(shape: PropertyShape): PropertyWithType[] {
+  if (shape.kind === 'object' && shape.properties) {
+    return Array.from(shape.properties.entries()).map(([name, propShape]) => ({
+      name,
+      type: shapeToTypeString(propShape),
+      detail: shapeToDetailString(propShape),
+    }));
+  }
+  if (shape.kind === 'array') {
+    const itemType = shape.itemShape ? shapeToTypeString(shape.itemShape) : 'any';
+    const itemDetail = shape.itemShape ? shapeToDetailString(shape.itemShape) : 'Type: any';
+    return [
+      { name: 'first', type: itemType, detail: itemDetail },
+      { name: 'last', type: itemType, detail: itemDetail },
+      { name: 'size', type: 'number', detail: 'Type: number' },
+    ];
+  }
+  if (shape.kind === 'primitive' && shape.primitiveType === 'string') {
+    return [{ name: 'size', type: 'number', detail: 'Type: number' }];
+  }
+  return [];
+}
+
+/**
+ * Merge a new property into an existing shape
+ */
+export function mergePropertyIntoShape(
+  shape: PropertyShape,
+  key: string,
+  valueShape: PropertyShape,
+): PropertyShape {
+  if (shape.kind !== 'object') {
+    const properties = new Map<string, PropertyShape>();
+    properties.set(key, valueShape);
+    return { kind: 'object', properties };
+  }
+
+  const newProperties = new Map(shape.properties);
+  newProperties.set(key, valueShape);
+  return { kind: 'object', properties: newProperties };
+}