@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/checks/valid-visible-if/index.ts

@@ -1,184 +0,0 @@
-import { type LiquidVariableLookup } from '@platformos/liquid-html-parser';
-import {
-  Severity,
-  SourceCodeType,
-  type LiquidCheckDefinition,
-  type JSONCheckDefinition,
-} from '../../types';
-import { getLocStart, nodeAtPath } from '../../json';
-import { getSchema, isBlockSchema, isSectionSchema } from '../../to-schema';
-import { reportWarning } from '../../utils';
-import {
-  getGlobalSettings,
-  getVariableLookupsInExpression,
-  validateLookup,
-  offsetAdjust,
-  type Vars,
-} from './visible-if-utils';
-
-// Note that unlike most other files in the `checks` directory, this exports two
-// checks: one for Liquid files and one for 'config/settings_schema.json'. They
-// perform the same check using the same logic (modulo differences extracting
-// the schema and determining warning start and end indices).
-
-const meta = {
-  code: 'ValidVisibleIf',
-  name: 'Validate visible_if expressions',
-  docs: {
-    description:
-      'Ensures visible_if expressions are well-formed and only reference settings keys that are defined',
-    recommended: true,
-    url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-visible-if',
-  },
-  severity: Severity.ERROR,
-  schema: {},
-  targets: [],
-};
-
-export const ValidVisibleIf: LiquidCheckDefinition = {
-  meta: { ...meta, type: SourceCodeType.LiquidHtml },
-
-  create(context) {
-    return {
-      async LiquidRawTag(node) {
-        if (node.name !== 'schema' || node.body.kind !== 'json') return;
-
-        const schema = await getSchema(context);
-
-        const { validSchema, ast } = schema ?? {};
-        if (
-          !validSchema ||
-          validSchema instanceof Error ||
-          !validSchema.settings?.some((setting) => 'visible_if' in setting) ||
-          !ast ||
-          ast instanceof Error
-        ) {
-          return;
-        }
-
-        const offset = node.blockStartPosition.end;
-        const settings = Object.fromEntries(
-          (await getGlobalSettings(context)).map((s) => [s, true] as const),
-        );
-        const currentFileSettings = Object.fromEntries(
-          validSchema.settings.map((setting) => [setting.id, true] as const),
-        );
-
-        const vars: Vars = { settings };
-        if (isSectionSchema(schema)) {
-          vars.section = { settings: currentFileSettings };
-        } else if (isBlockSchema(schema)) {
-          vars.block = { settings: currentFileSettings };
-        }
-
-        for (const [i, setting] of validSchema.settings.entries()) {
-          if (!('visible_if' in setting) || typeof setting.visible_if !== 'string') continue;
-
-          const visibleIfNode = nodeAtPath(ast, ['settings', i, 'visible_if'])!;
-
-          const varLookupsOrWarning = await getVariableLookupsInExpression(setting.visible_if);
-          if (varLookupsOrWarning === null) continue;
-
-          if ('warning' in varLookupsOrWarning) {
-            reportWarning(varLookupsOrWarning.warning, offset, visibleIfNode, context);
-            continue;
-          }
-
-          const report = (message: string | null, lookup: LiquidVariableLookup) => {
-            if (typeof message === 'string') {
-              context.report({
-                message,
-                // the JSONNode start location returned by `getLocStart`
-                // includes the opening quotation mark — whereas when we parse
-                // the inner expression, 0 is the location _inside_ the quotes.
-                // we add 1 to the offsets to compensate.
-                startIndex:
-                  offset + getLocStart(visibleIfNode) + lookup.position.start + offsetAdjust + 1,
-                endIndex:
-                  offset + getLocStart(visibleIfNode) + lookup.position.end + offsetAdjust + 1,
-              });
-            }
-          };
-
-          for (const lookup of varLookupsOrWarning) {
-            if (lookup.name === 'section' && isBlockSchema(schema)) {
-              //no-op, we don't know what section this block will be used in, so we can't validate that the setting exists
-            } else if (lookup.name === 'section' && !isSectionSchema(schema)) {
-              report(
-                `Invalid visible_if: can't refer to "section" when not in a section or block file.`,
-                lookup,
-              );
-            } else if (lookup.name === 'block' && !isBlockSchema(schema)) {
-              report(
-                `Invalid visible_if: can't refer to "block" when not in a block file.`,
-                lookup,
-              );
-            } else {
-              report(validateLookup(lookup, vars), lookup);
-            }
-          }
-        }
-      },
-    };
-  },
-};
-
-export const ValidVisibleIfSettingsSchema: JSONCheckDefinition = {
-  meta: { ...meta, type: SourceCodeType.JSON },
-
-  create(context) {
-    const relativePath = context.toRelativePath(context.file.uri);
-    if (relativePath !== 'config/settings_schema.json') return {};
-
-    return {
-      async Property(node) {
-        if (node.key.value !== 'visible_if' || node.value.type !== 'Literal') return;
-        const visibleIfExpression = node.value.value;
-        if (typeof visibleIfExpression !== 'string') return;
-        const offset = node.value.loc.start.offset;
-
-        const varLookupsOrWarning = await getVariableLookupsInExpression(visibleIfExpression);
-        if (varLookupsOrWarning === null) return;
-
-        if ('warning' in varLookupsOrWarning) {
-          context.report({
-            message: varLookupsOrWarning.warning,
-            startIndex: node.value.loc.start.offset,
-            endIndex: node.value.loc.end.offset,
-          });
-          return;
-        }
-
-        const settings = Object.fromEntries(
-          (await getGlobalSettings(context)).map((s) => [s, true] as const),
-        );
-
-        const vars: Vars = { settings };
-
-        const report = (message: string | null, lookup: LiquidVariableLookup) => {
-          if (typeof message === 'string') {
-            context.report({
-              message,
-              startIndex: offset + lookup.position.start + offsetAdjust + 1,
-              endIndex: offset + lookup.position.end + offsetAdjust + 1,
-            });
-          }
-        };
-
-        for (const lookup of varLookupsOrWarning) {
-          // settings_schema.json can't reference `section` or `block`.
-          if (lookup.name === 'section') {
-            report(
-              `Invalid visible_if: can't refer to "section" when not in a section file.`,
-              lookup,
-            );
-          } else if (lookup.name === 'block') {
-            report(`Invalid visible_if: can't refer to "block" when not in a block file.`, lookup);
-          } else {
-            report(validateLookup(lookup, vars), lookup);
-          }
-        }
-      },
-    };
-  },
-};

package/src/checks/valid-visible-if/visible-if-utils.ts

@@ -1,158 +0,0 @@
-import {
-  type LiquidVariableLookup,
-  NodeTypes,
-  toLiquidHtmlAST,
-} from '@platformos/liquid-html-parser';
-import { Context, SourceCodeType } from '../..';
-import { parseJSON } from '../../json';
-import { visit } from '../../visitor';
-
-export type Vars = { [key: string]: Vars | true };
-
-export const variableExpressionMatcher = /{{(.+?)}}/;
-export const adjustedPrefix = '{% if ';
-export const adjustedSuffix = ' %}{% endif %}';
-export const offsetAdjust = '{{'.length - adjustedPrefix.length;
-
-export async function getVariableLookupsInExpression(
-  expression: string,
-): Promise<LiquidVariableLookup[] | { warning: string } | null> {
-  // As of February 2025, parsers other than LiquidJS don't yet support
-  // expressions in {{ variable }} tags. So we have to do something a little
-  // gnarly — before parsing it we extract the expression from within the tag
-  // and plunk it into an `{% if <expression> %}{% endif %}` statement instead.
-  // This requires us to adjust the reported character ranges and offer slightly
-  // less useful messages on syntax errors, but otherwise should behave
-  // similarly to a proper `{{ <expression> }}` syntax whenever it lands.
-  const match = variableExpressionMatcher.exec(expression);
-  if (match == null) {
-    return {
-      warning: `Invalid visible_if expression. It should take the form "{{ <expression> }}".`,
-    };
-  }
-  const unwrappedExpression = match[1];
-
-  const adjustedExpression = `${adjustedPrefix}${unwrappedExpression}${adjustedSuffix}`;
-
-  try {
-    const innerAst = toLiquidHtmlAST(adjustedExpression, {
-      mode: 'strict',
-      allowUnclosedDocumentNode: false,
-    });
-
-    if (innerAst.children.length !== 1) {
-      throw new Error('Unexpected child count for DocumentNode');
-    }
-
-    const ifTag = innerAst.children[0];
-
-    if (ifTag.type !== 'LiquidTag' || ifTag.name !== 'if') {
-      throw new Error("Expected DocumentNode to contain 'if' tag");
-    }
-
-    const expressionNode = ifTag.markup;
-    if (typeof expressionNode === 'string') {
-      return {
-        warning: `Invalid visible_if expression.`,
-      };
-    }
-
-    if (
-      expressionNode.type === NodeTypes.LiquidLiteral &&
-      ['true', 'false'].includes(expressionNode.keyword)
-    ) {
-      // Those are OK
-      return null;
-    }
-
-    const vars = await visit<SourceCodeType.LiquidHtml, LiquidVariableLookup>(ifTag, {
-      VariableLookup: async (node) => node,
-    });
-
-    if (vars.length === 0) {
-      return {
-        warning: `visible_if expression contains no references to any settings. This is likely an error.`,
-      };
-    }
-
-    return vars;
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      // Because of our hackish approach, the underlying error is likely to
-      // include an incorrect character range and/or mention {% if %} tags.
-      // Squelch the details and just report it as a simple syntax error.
-      return { warning: 'Syntax error: cannot parse visible_if expression.' };
-    }
-
-    return { warning: String(error) };
-  }
-}
-
-export function validateLookup(lookup: LiquidVariableLookup, vars: Vars): string | null {
-  const normalized = getNormalizedLookups(lookup);
-
-  const poppedSegments = [];
-  let scope = vars;
-  while (normalized.length > 0) {
-    const segment = normalized.shift()!;
-    poppedSegments.push(segment);
-
-    // "noUncheckedIndexedAccess" is false in our tsconfig.json
-    const next = scope[segment] as true | Vars | undefined;
-
-    if (!next) {
-      return `Invalid variable: "${poppedSegments.join('.')}" was not found.`;
-    }
-
-    if (typeof next === 'boolean') {
-      if (normalized.length > 0) {
-        return `Invalid variable: "${poppedSegments.join(
-          '.',
-        )}" refers to a variable, but is being used here as a namespace.`;
-      }
-      return null;
-    }
-
-    scope = next;
-  }
-
-  // note this is the reverse of the above similar-looking case
-  return `Invalid variable: "${poppedSegments.join(
-    '.',
-  )}" refers to a namespace, but is being used here as a variable.`;
-}
-
-function getNormalizedLookups(lookup: LiquidVariableLookup) {
-  const nestedLookups = lookup.lookups.map((lookup) => {
-    if (lookup.type !== NodeTypes.String) {
-      throw new Error(`Expected lookups to be String nodes: ${JSON.stringify(lookup)}`);
-    }
-    return lookup.value;
-  });
-
-  return [lookup.name, ...nestedLookups];
-}
-
-export async function getGlobalSettings(context: Context<SourceCodeType>) {
-  const globalSettings: string[] = [];
-
-  try {
-    const uri = context.toUri('config/settings_schema.json');
-    const settingsFile = await context.fs.readFile(uri);
-    const settings = parseJSON(settingsFile);
-    if (Array.isArray(settings)) {
-      for (const group of settings) {
-        if ('settings' in group && Array.isArray(group.settings)) {
-          globalSettings.push(
-            ...group.settings.map((setting: any) => setting.id).filter((id: any) => id),
-          );
-        }
-      }
-    }
-  } catch (e) {
-    console.error('Error fetching global settings:', e);
-    // ignore absent or malformed settings schema
-  }
-
-  return globalSettings;
-}

package/src/tags/content-for.ts

@@ -1,25 +0,0 @@
-export const RESERVED_CONTENT_FOR_ARGUMENTS = [
-  'attributes',
-  'block',
-  'blocks',
-  'class',
-  'context',
-  'inherit',
-  'resource',
-  'resources',
-  'schema',
-  'section',
-  'sections',
-  'settings',
-  'snippet',
-  'snippets',
-  'src',
-  'style',
-  'styles',
-  'template',
-  'templates',
-];
-
-export const REQUIRED_CONTENT_FOR_ARGUMENTS = ['id', 'type'];
-
-export const CLOSEST_ARGUMENT = 'closest.';

package/src/to-schema.ts

@@ -1,231 +0,0 @@
-import {
-  ContentForMarkup,
-  LiquidRawTag,
-  NamedTags,
-  NodeTypes,
-} from '@platformos/liquid-html-parser';
-import { isPartial as isPartialPath } from '@platformos/platformos-common';
-import { parseJSON } from './json';
-import * as path from './path';
-import { toJSONAST } from './to-source-code';
-import {
-  AppBlockSchema,
-  ThemeBlockSchema,
-  IsValidSchema,
-  LiquidHtmlNode,
-  SectionSchema,
-  SourceCode,
-  SourceCodeType,
-  ThemeBlock,
-  ThemeSchemaType,
-  UriString,
-  Context,
-  Schema,
-  StaticBlockDef,
-} from './types';
-import { visit } from './visitor';
-
-export async function toSchema(
-  mode: 'app' | 'theme',
-  uri: UriString,
-  sourceCode: SourceCode,
-  isValidSchema: IsValidSchema | undefined,
-  isStrict: boolean = true,
-): Promise<AppBlockSchema | SectionSchema | ThemeBlockSchema | undefined> {
-  if (sourceCode.type !== SourceCodeType.LiquidHtml) return undefined;
-  switch (true) {
-    case mode === 'app' && isBlock(uri):
-      return toAppBlockSchema(uri, sourceCode.ast, isStrict);
-    case mode === 'theme' && isBlock(uri):
-      return toBlockSchema(uri, sourceCode.ast, isValidSchema, isStrict);
-    case mode === 'theme' && isSection(uri):
-      return toSectionSchema(uri, sourceCode.ast, isValidSchema, isStrict);
-    default:
-      return undefined;
-  }
-}
-
-export function isBlock(uri: UriString) {
-  return path.dirname(uri).endsWith('blocks');
-}
-
-export function isSection(uri: UriString) {
-  return path.dirname(uri).endsWith('sections');
-}
-
-export function isPartial(uri: UriString) {
-  return isPartialPath(uri);
-}
-
-// Legacy alias for backwards compatibility
-export const isSnippet = isPartial;
-
-export function isBlockSchema(
-  schema: AppBlockSchema | SectionSchema | ThemeBlockSchema | undefined,
-): schema is ThemeBlockSchema {
-  return schema?.type === ThemeSchemaType.Block;
-}
-
-export function isSectionSchema(
-  schema: AppBlockSchema | SectionSchema | ThemeBlockSchema | undefined,
-): schema is SectionSchema {
-  return schema?.type === ThemeSchemaType.Section;
-}
-
-async function toValidSchema<T>(
-  uri: string,
-  schemaNode: LiquidRawTag | Error,
-  parsed: any | Error,
-  isValidSchema: IsValidSchema | undefined,
-): Promise<T | Error> {
-  if (!isValidSchema) return new Error('No JSON validator provided');
-  if (schemaNode instanceof Error) return parsed;
-  if (await isValidSchema(uri, schemaNode.body.value)) {
-    return parsed as T;
-  } else {
-    return new Error('Invalid schema');
-  }
-}
-
-export async function toBlockSchema(
-  uri: UriString,
-  liquidAst: LiquidHtmlNode | Error,
-  isValidSchema: IsValidSchema | undefined,
-  isStrict: boolean,
-): Promise<ThemeBlockSchema> {
-  const name = path.basename(uri, '.liquid');
-  const schemaNode = await toSchemaNode(liquidAst);
-  const staticBlockDefs = await toStaticBlockDefs(liquidAst);
-  const parsed = toParsed(schemaNode, isStrict);
-  const ast = toAst(schemaNode);
-
-  return {
-    type: ThemeSchemaType.Block,
-    validSchema: await toValidSchema<ThemeBlock.Schema>(uri, schemaNode, parsed, isValidSchema),
-    offset: schemaNode instanceof Error ? 0 : schemaNode.blockStartPosition.end,
-    name,
-    parsed,
-    ast,
-    value: schemaNode instanceof Error ? '' : schemaNode.body.value,
-    staticBlockDefs,
-  };
-}
-
-// Coincidentally very similar right now... but could be different in the future
-// given there might be a plan to support folders in the blocks folder.
-// e.g. if we start having a stricter "parsed" object / ways to get settings.
-export async function toSectionSchema(
-  uri: UriString,
-  liquidAst: LiquidHtmlNode | Error,
-  isValidSchema: IsValidSchema | undefined,
-  isStrict: boolean,
-): Promise<SectionSchema> {
-  const name = path.basename(uri, '.liquid');
-  const schemaNode = await toSchemaNode(liquidAst);
-  const staticBlockDefs = await toStaticBlockDefs(liquidAst);
-  const parsed = toParsed(schemaNode, isStrict);
-  const ast = toAst(schemaNode);
-
-  return {
-    type: ThemeSchemaType.Section,
-    validSchema: await toValidSchema(uri, schemaNode, parsed, isValidSchema),
-    offset: schemaNode instanceof Error ? 0 : schemaNode.blockStartPosition.end,
-    name,
-    parsed,
-    ast,
-    value: schemaNode instanceof Error ? '' : schemaNode.body.value,
-    staticBlockDefs,
-  };
-}
-
-// validSchema not implemented yet. You can still `visit` the ast.
-export async function toAppBlockSchema(
-  uri: UriString,
-  liquidAst: LiquidHtmlNode | Error,
-  isStrict: boolean,
-): Promise<AppBlockSchema> {
-  const name = path.basename(uri, '.liquid');
-  const schemaNode = await toSchemaNode(liquidAst);
-  const parsed = toParsed(schemaNode, isStrict);
-  const ast = toAst(schemaNode);
-
-  return {
-    type: ThemeSchemaType.AppBlock,
-    offset: schemaNode instanceof Error ? 0 : schemaNode.blockStartPosition.end,
-    name,
-    parsed,
-    ast,
-    value: schemaNode instanceof Error ? '' : schemaNode.body.value,
-  };
-}
-
-async function toSchemaNode(ast: LiquidHtmlNode | Error): Promise<Error | LiquidRawTag> {
-  if (ast instanceof Error) return ast;
-  return (
-    (
-      await visit<SourceCodeType.LiquidHtml, LiquidRawTag>(ast, {
-        async LiquidRawTag(node) {
-          if (node.name === 'schema') {
-            return node;
-          }
-        },
-      })
-    )[0] ?? new Error('No schema tag found')
-  );
-}
-
-async function toStaticBlockDefs(ast: LiquidHtmlNode | Error): Promise<StaticBlockDef[]> {
-  if (ast instanceof Error) return [];
-  return await visit<SourceCodeType.LiquidHtml, StaticBlockDef>(ast, {
-    async LiquidTag(node) {
-      if (node.name !== NamedTags.content_for) return;
-      if (typeof node.markup === 'string') return;
-      const contentForMarkup: ContentForMarkup = node.markup;
-      if (contentForMarkup.contentForType.value !== 'block') return;
-      const type = contentForMarkup.args.find((x) => x.name === 'type');
-      const id = contentForMarkup.args.find((x) => x.name === 'id');
-      if (!type || !id) return;
-      if (type.value.type !== NodeTypes.String) return;
-      if (id.value.type !== NodeTypes.String) return;
-
-      return {
-        type: type.value.value,
-        id: id.value.value,
-      };
-    },
-  });
-}
-
-export function getSchema(context: Context<SourceCodeType.LiquidHtml, Schema>) {
-  const name = path.basename(context.file.uri, '.liquid');
-  switch (true) {
-    case isBlock(context.file.uri):
-      return context.getBlockSchema?.(name);
-    case isSection(context.file.uri):
-      return context.getSectionSchema?.(name);
-    default:
-      return undefined;
-  }
-}
-
-export async function getSchemaFromJSON(context: Context<SourceCodeType.JSON, Schema>) {
-  const originalSource = context.file.source;
-
-  const parsed = parseJSON(originalSource);
-  const ast = toJSONAST(originalSource);
-
-  return {
-    parsed,
-    ast,
-  };
-}
-
-function toParsed(schemaNode: LiquidRawTag | Error, isStrict: boolean): any | Error {
-  if (schemaNode instanceof Error) return schemaNode;
-  return parseJSON(schemaNode.body.value, undefined, isStrict);
-}
-
-function toAst(schemaNode: LiquidRawTag | Error): SourceCode<SourceCodeType.JSON>['ast'] | Error {
-  if (schemaNode instanceof Error) return schemaNode;
-  return toJSONAST(schemaNode.body.value);
-}

package/src/types/schemas/index.ts

@@ -1,5 +0,0 @@
-export { ThemeBlock } from './theme-block';
-export { Section } from './section';
-export { Setting } from './setting';
-export { Preset } from './preset';
-export { Template } from './template';

package/src/types/schemas/preset.ts

@@ -1,52 +0,0 @@
-import { Setting } from './setting';
-
-export declare namespace Preset {
-  // Preset definitions
-  export type Preset =
-    | {
-        name: string;
-        settings?: Setting.Values;
-        blocks?: PresetBlockHash;
-        block_order?: string[];
-      }
-    | {
-        name: string;
-        settings?: Setting.Values;
-        blocks?: PresetBlockForArray[];
-      }
-    | { name: string; settings?: Setting.Values };
-
-  // Reuse the block preset types from ThemeBlock namespace
-  export type PresetBlockBase = {
-    type: string;
-    settings?: Setting.Values;
-    static?: boolean;
-    blocks?: PresetBlockHash | PresetBlockForArray[];
-  };
-
-  export type PresetBlockForHash = PresetBlockBase & {
-    block_order?: string[];
-  };
-
-  export type PresetBlockForArray = PresetBlockBase & {
-    id?: string;
-  };
-
-  // Hash format for blocks
-  export type PresetBlockHash = {
-    [id: string]: PresetBlockForHash;
-  };
-
-  /** Base type for presets */
-  export type BlockPresetBase = {
-    /** Refers to a block type. blocks/{type}.liquid */
-    type: string;
-    settings?: Setting.Values;
-  };
-
-  // prettier-ignore
-  export type Block = (
-    | PresetBlockForHash
-    | PresetBlockForArray
-  );
-}