@platformos/platformos-graph 0.0.2

package/src/toSourceCode.ts

@@ -0,0 +1,80 @@
+import {
+  asError,
+  toSourceCode as tcToSourceCode,
+  UriString,
+} from '@platformos/platformos-check-common';
+import { parse as acornParse, Program } from 'acorn';
+import {
+  CssSourceCode,
+  FileSourceCode,
+  ImageSourceCode,
+  JsSourceCode,
+  SUPPORTED_ASSET_IMAGE_EXTENSIONS,
+  SvgSourceCode,
+} from './types';
+import { extname } from './utils';
+
+export async function toCssSourceCode(uri: UriString, source: string): Promise<CssSourceCode> {
+  return {
+    type: 'css',
+    uri,
+    source,
+    ast: new Error('File parsing not implemented yet'), // Placeholder for CSS parsing
+  };
+}
+
+export async function toSvgSourceCode(uri: UriString, source: string): Promise<SvgSourceCode> {
+  return {
+    type: 'svg',
+    uri,
+    source,
+    ast: new Error('File parsing not implemented yet'), // Placeholder for SVG parsing
+  };
+}
+
+async function toImageSourceCode(uri: UriString, source: string): Promise<ImageSourceCode> {
+  return {
+    type: 'image',
+    uri,
+    source,
+    ast: new Error('Image files are not parsed'),
+  };
+}
+
+export async function toJsSourceCode(uri: UriString, source: string): Promise<JsSourceCode> {
+  return {
+    type: 'javascript',
+    uri,
+    source,
+    ast: parseJs(source),
+  };
+}
+
+export function parseJs(source: string): Program | Error {
+  try {
+    return acornParse(source, {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+    });
+  } catch (error) {
+    return asError(error);
+  }
+}
+
+export async function toSourceCode(uri: UriString, source: string): Promise<FileSourceCode> {
+  const extension = extname(uri);
+
+  if (extension === 'json' || extension === 'liquid' || extension === 'graphql') {
+    return tcToSourceCode(uri, source);
+  } else if (extension === 'js') {
+    return toJsSourceCode(uri, source);
+  } else if (extension === 'css') {
+    return toCssSourceCode(uri, source);
+  } else if (extension === 'svg') {
+    return toCssSourceCode(uri, source);
+  } else if (SUPPORTED_ASSET_IMAGE_EXTENSIONS.includes(extension)) {
+    return toImageSourceCode(uri, source);
+  } else {
+    throw new Error(`Unknown source code type for ${uri}`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,213 @@
+import {
+  JSONSourceCode,
+  LiquidSourceCode,
+  Dependencies as ThemeCheckDependencies,
+  UriString,
+  Reference,
+  Location,
+  Range,
+  GraphQLSourceCode,
+} from '@platformos/platformos-check-common';
+import { Program } from 'acorn';
+
+export interface IDependencies {
+  fs: ThemeCheckDependencies['fs'];
+
+  /**
+   * Asynchronously get the block schema for 'blocks/${name}.liquid'
+   * May return undefined when the theme isn't preloaded.
+   */
+  getBlockSchema: NonNullable<ThemeCheckDependencies['getBlockSchema']>;
+
+  /**
+   * Asynchronously get the section schema for 'section/${name}.liquid'
+   * May return undefined when the theme isn't preloaded or if there are none.
+   */
+  getSectionSchema: NonNullable<ThemeCheckDependencies['getSectionSchema']>;
+
+  /** Optional perf improvement if you somehow have access to pre-computed source code info */
+  getSourceCode?: (uri: UriString) => Promise<FileSourceCode>;
+
+  /** A way to link <custom-element> to its window.customElements.define statement */
+  getWebComponentDefinitionReference: (
+    customElementName: string,
+  ) => { assetName: string; range: Range } | undefined;
+}
+
+export type Dependencies = Required<IDependencies>;
+
+export type AugmentedDependencies = Dependencies & {
+  getThemeBlockNames: () => Promise<string[]>;
+};
+
+export interface ThemeGraph {
+  rootUri: UriString;
+  entryPoints: ThemeModule[];
+  modules: Record<UriString, ThemeModule>;
+}
+
+export type ThemeModule =
+  | LiquidModule
+  | JsonModule
+  | JavaScriptModule
+  | CssModule
+  | SvgModule
+  | ImageModule;
+
+export type FileSourceCode =
+  | LiquidSourceCode
+  | JSONSourceCode
+  | GraphQLSourceCode
+  | JsSourceCode
+  | CssSourceCode
+  | SvgSourceCode
+  | ImageSourceCode;
+
+export interface SerializableGraph {
+  rootUri: UriString;
+  nodes: SerializableNode[];
+  edges: SerializableEdge[];
+}
+
+export interface SerializableEdge {
+  source: Location;
+  target: Location;
+}
+
+export type SerializableNode = Pick<ThemeModule, 'uri' | 'type' | 'kind' | 'exists'>;
+
+export interface LiquidModule extends IThemeModule<ModuleType.Liquid> {
+  kind: LiquidModuleKind;
+}
+
+export interface JsonModule extends IThemeModule<ModuleType.Json> {
+  kind: JsonModuleKind;
+}
+
+export interface JavaScriptModule extends IThemeModule<ModuleType.JavaScript> {
+  kind: 'unused';
+}
+
+export interface CssModule extends IThemeModule<ModuleType.Css> {
+  kind: 'unused';
+}
+
+export interface SvgModule extends IThemeModule<ModuleType.Svg> {
+  kind: 'unused';
+}
+
+export interface ImageModule extends IThemeModule<ModuleType.Image> {
+  kind: 'unused';
+}
+
+export interface IThemeModule<T extends ModuleType> {
+  /** Used as a discriminant in the ThemeNode union */
+  type: T;
+
+  /** Should be normalized. Used as key. */
+  uri: UriString;
+
+  /**
+   * Outgoing references to other modules. e.g. {% render 'child' %} from parent
+   *
+   * The source URI of all dependencies is this module.
+   */
+  dependencies: Reference[];
+
+  /**
+   * Ingoing references from other modules. e.g. {% render 'child' %} in parent
+   *
+   * The target URI of all dependencies is this module.
+   */
+  references: Reference[];
+
+  /**
+   * Since you could have files that depend on files that don't exist,
+   *
+   * this property will be used to quickly identify those.
+   */
+  exists?: boolean;
+}
+
+export const enum ModuleType {
+  Liquid = 'Liquid',
+  JavaScript = 'JavaScript',
+  Json = 'JSON',
+  Css = 'CSS',
+  Svg = 'SVG',
+  Image = 'Image',
+}
+
+export const enum JsonModuleKind {
+  /** templates/*.json files */
+  Template = 'template',
+
+  /** sections/*.json files */
+  SectionGroup = 'section-group',
+}
+
+export const enum LiquidModuleKind {
+  /** layout/*.liquid files */
+  Layout = 'layout',
+
+  /** sections/*.liquid files */
+  Section = 'section',
+
+  /** blocks/*.liquid files */
+  Block = 'block',
+
+  /** app/views/partials/*.liquid files */
+  Partial = 'partial',
+
+  /** templates/*.liquid files (forgot those existed...) */
+  Template = 'template',
+}
+
+export const SUPPORTED_ASSET_IMAGE_EXTENSIONS = [
+  'jpg',
+  'jpeg',
+  'png',
+  'gif',
+  'webp',
+  'heic',
+  'ico',
+];
+
+export interface CssSourceCode {
+  type: 'css';
+  uri: UriString;
+  source: string;
+  ast: any | Error;
+}
+
+export interface SvgSourceCode {
+  type: 'svg';
+  uri: UriString;
+  source: string;
+  ast: any | Error;
+}
+
+export interface ImageSourceCode {
+  type: 'image';
+  uri: UriString;
+  source: string;
+  ast: any | Error;
+}
+
+export interface JsSourceCode {
+  type: 'javascript';
+  uri: UriString;
+  source: string;
+  ast: Program | Error;
+}
+
+export { Reference, Range, Location };
+
+export type Void = void | Void[]; /** e.g. product-element, */
+
+export type WebComponentMap = Map<WebComponentName, WebComponentDefinition>;
+export type WebComponentName = string;
+export type WebComponentDefinition = {
+  assetName: string; // Relative path to the asset file
+  range: [number, number]; // Start and end positions in the file
+};

package/src/utils/index.ts

@@ -0,0 +1,51 @@
+import { UriString } from '@platformos/platformos-check-common';
+import { AbstractFileSystem } from '@platformos/platformos-common';
+import { AugmentedDependencies } from '../types';
+
+export function unique<T>(array: T[]): T[] {
+  return [...new Set(array)];
+}
+
+export function assertNever(module: never) {
+  throw new Error(`Unknown module type ${module}`);
+}
+
+export function unexpected(): Error {
+  return new Error('Unexpected code path encountered');
+}
+
+export const identity = <T>(x: T): T => x;
+
+export function isString(x: unknown): x is string {
+  return typeof x === 'string';
+}
+
+export function extname(uri: UriString): string {
+  return uri.split('.').pop() || '';
+}
+
+export async function exists(fs: AbstractFileSystem, uri: UriString): Promise<boolean> {
+  return fs
+    .stat(uri)
+    .then(() => true)
+    .catch(() => false);
+}
+
+export async function acceptsLocalBlocks(
+  sectionType: string,
+  deps: AugmentedDependencies,
+): Promise<boolean | Error> {
+  const sectionSchema = await deps.getSectionSchema(sectionType).catch((_) => undefined);
+  if (!sectionSchema) {
+    return new Error('Section does not exist');
+  }
+
+  const validSchema = sectionSchema.validSchema;
+  if (validSchema instanceof Error) {
+    return validSchema;
+  }
+
+  return (validSchema.blocks ?? []).some((block) => {
+    return block.type && 'name' in block && block.name;
+  });
+}

package/tsconfig.build.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "./src/**/*.ts",
+    "./src/**/*.json"
+  ],
+  "exclude": [
+    "node_modules",
+    "src/**/*.spec.ts"
+  ],
+  "references": [
+    {
+      "path": "../platformos-check-common/tsconfig.build.json"
+    },
+    {
+      "path": "../liquid-html-parser/tsconfig.build.json"
+    },
+    { "path": "../platformos-common/tsconfig.build.json" }
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": [
+    "./src/**/*.ts",
+    "./src/**/*.json"
+  ],
+  "exclude": [
+    "./dist"
+  ],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "tsBuildInfoFile": "dist/tsconfig.tsbuildinfo",
+    "paths": {
+      "@platformos/liquid-html-parser": [
+        "../liquid-html-parser/src"
+      ],
+      "@platformos/platformos-check-common": [
+        "../platformos-check-common/src"
+      ],
+      "@platformos/platformos-common": [
+        "../platformos-common/src"
+      ],
+    }
+  },
+  "references": [
+    {
+      "path": "../platformos-check-common"
+    },
+    {
+      "path": "../liquid-html-parser"
+    },
+    {
+      "path": "../platformos-common"
+    }
+  ]
+}