@platformos/platformos-check-common 0.0.7 → 0.0.8

package/src/types/schemas/theme-block.ts

@@ -1,34 +0,0 @@
-import { Setting } from './setting';
-import { Preset } from './preset';
-
-export declare namespace ThemeBlock {
-  /** Typed content of {% schema %} after passing validation */
-  export interface Schema {
-    name?: string;
-    settings?: Setting.Any[];
-    blocks?: Block[];
-    presets?: Preset.Preset[];
-    class?: string;
-    tag?: string | null;
-  }
-
-  export type ThemeBlock = {
-    type: '@theme';
-  };
-
-  export type AppBlock = {
-    type: '@app';
-  };
-
-  export type SpecificThemeBlock = {
-    /** blocks/{type}.liquid */
-    type: string;
-  };
-
-  // prettier-ignore
-  export type Block = (
-    | ThemeBlock
-    | AppBlock
-    | SpecificThemeBlock
-  );
-}

package/src/types/theme-schemas.ts

@@ -1,80 +0,0 @@
-import { SourceCode, SourceCodeType } from '../types';
-import { Section, ThemeBlock } from './schemas';
-
-export * from './schemas';
-
-export enum ThemeSchemaType {
-  AppBlock = 'app-block',
-  Block = 'block',
-  Section = 'section',
-}
-
-/** {% content_for 'block', type: type, id: id %}*/
-export type StaticBlockDef = { type: string; id: string };
-
-/**
- * A ThemeSchema represents the `{% schema %}` contents of a block or section file.
- *
- * `ast` and `parsed` will be instances of `Error` if there was an error parsing
- * the Liquid file or the JSON.
- *
- * There is no guarantee that the `ast` or `parsed` fields are backend-valid.
- */
-export interface ThemeSchema<T extends ThemeSchemaType> {
-  /** section or block */
-  type: T;
-
-  /** `section/${name}.liquid` */
-  name: string;
-
-  /** Parsed as an AST (with position information) or an Error */
-  ast: SourceCode<SourceCodeType.JSON>['ast'] | Error;
-
-  /** Parsed as a JavaScript object or an Error */
-  parsed: any | Error;
-
-  /** 0-based index of the start of JSON object in the document */
-  offset: number;
-
-  /** schema node value */
-  value: string;
-}
-
-/** See {@link ThemeSchema} */
-export interface ThemeBlockSchema extends ThemeSchema<ThemeSchemaType.Block> {
-  /**
-   * @example
-   * const schema = await context.getBlockSchema('product');
-   * const validSchema = schema?.validSchema;
-   * if (!validSchema || validSchema instanceof Error) return;
-   *
-   * for (const block of validSchema.blocks ?? []) {
-   *  // do something
-   * }
-   */
-  validSchema: ThemeBlock.Schema | Error;
-
-  /** type/id pairs found in the body of the file */
-  staticBlockDefs: StaticBlockDef[];
-}
-
-/** See {@link ThemeSchema} */
-export interface SectionSchema extends ThemeSchema<ThemeSchemaType.Section> {
-  /**
-   * @example
-   * const schema = await context.getSectionSchema('product');
-   * const validSchema = schema?.validSchema;
-   * if (!validSchema || validSchema instanceof Error) return;
-   *
-   * for (const block of validSchema.blocks ?? []) {
-   *  // do something
-   * }
-   */
-  validSchema: Section.Schema | Error;
-
-  /** type/id pairs found in the body of the file */
-  staticBlockDefs: StaticBlockDef[];
-}
-
-/** TODO setup validSchema like the other ones. */
-export interface AppBlockSchema extends ThemeSchema<ThemeSchemaType.AppBlock> {}

package/src/utils/block.ts

@@ -1,300 +0,0 @@
-import {
-  JSONNode,
-  LiteralNode,
-  Preset,
-  Section,
-  SourceCodeType,
-  ThemeBlock,
-  Context,
-  StaticBlockDef,
-} from '../types';
-import { getLocEnd, getLocStart, nodeAtPath } from '../json';
-import { doesFileExist } from './file-utils';
-
-export type BlockDefNodeWithPath = {
-  node: Section.Block | ThemeBlock.Block;
-  path: string[];
-};
-
-export type PresetBlockNodeWithPath = {
-  node: Preset.Block;
-  path: string[];
-};
-
-export function getBlocks(validSchema: ThemeBlock.Schema | Section.Schema) {
-  const rootLevelThemeBlocks: BlockDefNodeWithPath[] = [];
-  const rootLevelLocalBlocks: BlockDefNodeWithPath[] = [];
-  const presetLevelBlocks: { [key: number]: PresetBlockNodeWithPath[] } = {};
-  const defaultLevelBlocks: BlockDefNodeWithPath[] = [];
-
-  const rootLevelBlocks = validSchema.blocks;
-  const presets = validSchema.presets;
-
-  // Helper function to categorize blocks
-  function categorizeRootLevelBlocks(block: Preset.Block, index: number) {
-    if (!block) return;
-    const hasName = 'name' in block;
-
-    if (hasName) {
-      rootLevelLocalBlocks.push({
-        node: block,
-        path: ['blocks', String(index), 'type'],
-      });
-    } else if (block.type !== '@app') {
-      rootLevelThemeBlocks.push({
-        node: block,
-        path: ['blocks', String(index), 'type'],
-      });
-    }
-  }
-
-  function categorizePresetLevelBlocks(
-    block: Preset.Block,
-    currentPath: string[],
-    depth: number = 0,
-  ) {
-    if (!block) return;
-
-    if (!presetLevelBlocks[depth]) {
-      presetLevelBlocks[depth] = [];
-    }
-
-    presetLevelBlocks[depth].push({
-      node: block,
-      path: currentPath.concat('type'),
-    });
-
-    if ('blocks' in block) {
-      if (Array.isArray(block.blocks)) {
-        block.blocks.forEach((nestedBlock: Preset.PresetBlockForArray, index: number) => {
-          categorizePresetLevelBlocks(
-            nestedBlock,
-            currentPath.concat('blocks', String(index)),
-            depth + 1,
-          );
-        });
-      } else if (typeof block.blocks === 'object' && block.blocks !== null) {
-        Object.entries(block.blocks).forEach(([key, nestedBlock]) => {
-          categorizePresetLevelBlocks(nestedBlock, currentPath.concat('blocks', key), depth + 1);
-        });
-      }
-    }
-  }
-
-  function categorizeDefaultLevelBlocks(block: Preset.Block, index: number) {
-    const hasName = 'name' in block;
-
-    if (hasName) {
-      defaultLevelBlocks.push({
-        node: block,
-        path: ['default', 'blocks', String(index), 'type'],
-      });
-    }
-  }
-
-  if (Array.isArray(rootLevelBlocks)) {
-    rootLevelBlocks.forEach((block, index) => {
-      categorizeRootLevelBlocks(block, index);
-    });
-  }
-
-  if (presets) {
-    presets.forEach((preset: Preset.Preset, presetIndex: number) => {
-      if ('blocks' in preset && preset.blocks) {
-        if (Array.isArray(preset.blocks)) {
-          preset.blocks.forEach((block, blockIndex) => {
-            categorizePresetLevelBlocks(
-              block,
-              ['presets', String(presetIndex), 'blocks', String(blockIndex)],
-              0,
-            );
-          });
-        } else if (typeof preset.blocks === 'object') {
-          Object.entries(preset.blocks).forEach(([key, block]) => {
-            categorizePresetLevelBlocks(block, ['presets', String(presetIndex), 'blocks', key], 0);
-          });
-        }
-      }
-    });
-  }
-
-  if ('default' in validSchema) {
-    validSchema.default?.blocks?.forEach((block, index) => {
-      categorizeDefaultLevelBlocks(block, index);
-    });
-  }
-
-  return {
-    rootLevelThemeBlocks,
-    rootLevelLocalBlocks,
-    presetLevelBlocks,
-    defaultLevelBlocks,
-  };
-}
-
-export function isInvalidPresetBlock(
-  blockId: string,
-  blockNode: Preset.Block,
-  rootLevelThemeBlocks: BlockDefNodeWithPath[],
-  staticBlockDefs: StaticBlockDef[],
-): boolean {
-  if (blockNode.static) {
-    return !staticBlockDefs.some((block) => block.type === blockNode.type && block.id === blockId);
-  }
-
-  const isPrivateBlockType = blockNode.type.startsWith('_');
-  const isThemeInRootLevel = rootLevelThemeBlocks.some((block) => block.node.type === '@theme');
-  const needsExplicitRootBlock = isPrivateBlockType || !isThemeInRootLevel;
-  const isPresetInRootLevel = rootLevelThemeBlocks.some(
-    (block) => block.node.type === blockNode.type,
-  );
-
-  return !isPresetInRootLevel && needsExplicitRootBlock;
-}
-
-export function isInvalidDefaultBlock(
-  blockNode: Section.Block | ThemeBlock.Block,
-  rootLevelThemeBlocks: BlockDefNodeWithPath[],
-): boolean {
-  const isPrivateBlockType = blockNode.type.startsWith('_');
-  const isThemeInRootLevel = rootLevelThemeBlocks.some((block) => block.node.type === '@theme');
-  const needsExplicitRootBlock = isPrivateBlockType || !isThemeInRootLevel;
-  const isDefaultInRootLevel = rootLevelThemeBlocks.some(
-    (block) => block.node.type === blockNode.type,
-  );
-
-  return !isDefaultInRootLevel && needsExplicitRootBlock;
-}
-
-async function validateBlockTargeting(
-  nestedBlock: Preset.PresetBlockForArray | Preset.PresetBlockForHash,
-  nestedPath: string[],
-  context: Context<SourceCodeType.LiquidHtml>,
-  parentNode: Preset.PresetBlockForArray | Preset.PresetBlockForHash,
-  rootLevelThemeBlocks: BlockDefNodeWithPath[],
-  allowedBlockTypes: string[],
-  offset: number,
-  ast: JSONNode,
-  staticBlockDefs: StaticBlockDef[] = [],
-) {
-  const typeNode = nodeAtPath(ast, nestedPath)! as LiteralNode;
-  const blockId = 'id' in nestedBlock ? nestedBlock.id! : nestedPath.at(-2)!;
-
-  if (typeNode) {
-    if (isInvalidPresetBlock(blockId, nestedBlock, rootLevelThemeBlocks, staticBlockDefs)) {
-      const isStaticBlock = !!nestedBlock.static;
-      const isPrivateBlock = nestedBlock.type.startsWith('_');
-      const errorMessage = isStaticBlock
-        ? `Could not find a static block of type "${nestedBlock.type}" with id "${blockId}" in "blocks/${parentNode.type}.liquid".`
-        : isPrivateBlock
-          ? `Private block type "${nestedBlock.type}" is not allowed in "${parentNode.type}" blocks.`
-          : `Block type "${nestedBlock.type}" is not allowed in "${
-              parentNode.type
-            }" blocks. Allowed types are: ${allowedBlockTypes.join(', ')}.`;
-      reportWarning(errorMessage, offset, typeNode, context);
-    }
-
-    const exists = await validateBlockFileExistence(nestedBlock.type, context);
-
-    if (!exists) {
-      reportWarning(
-        `Theme block 'blocks/${nestedBlock.type}.liquid' does not exist.`,
-        offset,
-        typeNode,
-        context,
-      );
-    }
-  }
-
-  if ('blocks' in nestedBlock && nestedBlock.blocks) {
-    validateNestedBlocks(
-      context,
-      nestedBlock,
-      nestedBlock.blocks,
-      nestedPath.slice(0, -1),
-      offset,
-      ast,
-    );
-  }
-}
-
-export async function validateNestedBlocks(
-  context: Context<SourceCodeType.LiquidHtml>,
-  parentNode: Preset.PresetBlockForHash | Preset.PresetBlockForArray,
-  nestedBlocks: Preset.PresetBlockHash | Preset.PresetBlockForArray[],
-  currentPath: string[],
-  offset: number,
-  ast: JSONNode,
-) {
-  if (!nestedBlocks) return;
-
-  const parentSchema = await context.getBlockSchema?.(parentNode.type);
-  if (!parentSchema || parentSchema instanceof Error) return;
-
-  const { validSchema, staticBlockDefs } = parentSchema;
-  if (!validSchema || validSchema instanceof Error) return;
-
-  const { rootLevelThemeBlocks } = getBlocks(validSchema);
-  const allowedBlockTypes = rootLevelThemeBlocks.map((block) => block.node.type);
-
-  if (Array.isArray(nestedBlocks)) {
-    await Promise.all(
-      nestedBlocks.map((nestedBlock, index) => {
-        const nestedPath = currentPath.concat(['blocks', String(index), 'type']);
-        return validateBlockTargeting(
-          nestedBlock,
-          nestedPath,
-          context,
-          parentNode,
-          rootLevelThemeBlocks,
-          allowedBlockTypes,
-          offset,
-          ast,
-          staticBlockDefs,
-        );
-      }),
-    );
-  } else if (typeof nestedBlocks === 'object') {
-    await Promise.all(
-      Object.entries(nestedBlocks).map(([key, nestedBlock]) => {
-        const nestedPath = currentPath.concat(['blocks', key, 'type']);
-        return validateBlockTargeting(
-          nestedBlock,
-          nestedPath,
-          context,
-          parentNode,
-          rootLevelThemeBlocks,
-          allowedBlockTypes,
-          offset,
-          ast,
-          staticBlockDefs,
-        );
-      }),
-    );
-  }
-}
-
-export function reportWarning(
-  message: string,
-  offset: number,
-  astNode: JSONNode,
-  context: Context<SourceCodeType.LiquidHtml>,
-) {
-  context.report({
-    message,
-    startIndex: offset + getLocStart(astNode),
-    endIndex: offset + getLocEnd(astNode),
-  });
-}
-
-export async function validateBlockFileExistence(
-  blockType: string,
-  context: Context<SourceCodeType.LiquidHtml>,
-): Promise<boolean> {
-  if (blockType === '@theme' || blockType === '@app') {
-    return true;
-  }
-
-  const blockPath = `blocks/${blockType}.liquid`;
-  return await doesFileExist(context, blockPath);
-}

package/src/utils/markup.ts

@@ -1,10 +0,0 @@
-import { ContentForMarkup } from '@platformos/liquid-html-parser';
-
-export function isContentForBlock(
-  nodeMarkup: string | ContentForMarkup,
-): nodeMarkup is ContentForMarkup {
-  if (typeof nodeMarkup === 'string') {
-    return false;
-  }
-  return nodeMarkup.contentForType.value === 'block';
-}