forgebook 0.3.3 → 0.4.0

package/dist/src/valueSchema.js

@@ -0,0 +1,196 @@
+import { isArgList, isArgObject } from "./messages.js";
+/** Whether a value is a plain object. */
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** The keywords a schema may use. */
+const KEYWORDS = [
+    "title",
+    "description",
+    "default",
+    "type",
+    "enum",
+    "const",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "pattern",
+    "items",
+    "minItems",
+    "maxItems",
+    "properties",
+    "required",
+    "additionalProperties",
+    "anyOf"
+];
+/** The types JSON Schema names. */
+const SCHEMA_TYPES = [
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "null",
+    "object",
+    "array"
+];
+/** Whether a keyword holds a number, when it is there: one that holds another thing would refuse nothing. */
+const areNumbers = (schema, keywords) => keywords.every((keyword) => schema[keyword] === undefined || typeof schema[keyword] === "number");
+/** Whether a pattern compiles, and repeats no repeat (`(a+)+`), the form that hangs a page on a short text. */
+const isUsablePattern = (pattern) => {
+    if (pattern === undefined)
+        return true;
+    if (typeof pattern !== "string" || /\([^)]*[+*}][^)]*\)[+*{]/.test(pattern))
+        return false;
+    try {
+        return new RegExp(pattern, "u") !== undefined;
+    }
+    catch {
+        return false;
+    }
+};
+/** Whether a keyword holding one schema, or several, holds schemas. */
+const areNested = (value) => {
+    const { items, properties, additionalProperties, anyOf } = value;
+    return ((items === undefined || isValueSchema(items)) &&
+        (properties === undefined || (isRecord(properties) && Object.values(properties).every(isValueSchema))) &&
+        (additionalProperties === undefined ||
+            typeof additionalProperties === "boolean" ||
+            isValueSchema(additionalProperties)) &&
+        (anyOf === undefined || (Array.isArray(anyOf) && anyOf.every(isValueSchema))));
+};
+/** Whether the keywords of one level hold what they say. */
+const areLeavesRead = (value) => {
+    const { type, required } = value;
+    const types = type === undefined ? [] : [type].flat();
+    return (types.every((each) => SCHEMA_TYPES.includes(each)) &&
+        (value["enum"] === undefined || Array.isArray(value["enum"])) &&
+        (required === undefined ||
+            (Array.isArray(required) && required.every((name) => typeof name === "string"))) &&
+        areNumbers(value, ["minimum", "maximum", "minLength", "maxLength", "minItems", "maxItems"]) &&
+        isUsablePattern(value["pattern"]));
+};
+/**
+ * Whether a module's `schema` is one this check reads in full, at any depth: a keyword it does not know, or one holding what
+ * it cannot use, would let through what the schema seems to refuse.
+ *
+ * @param value - the module's export.
+ */
+export const isValueSchema = (value) => isRecord(value) &&
+    Object.keys(value).every((key) => KEYWORDS.includes(key)) &&
+    areLeavesRead(value) &&
+    areNested(value);
+/** Whether a value is of one of JSON Schema's types. */
+const isOfType = (type, value) => {
+    switch (type) {
+        case "string":
+        case "boolean":
+            return typeof value === type;
+        case "number":
+            return typeof value === "number" && Number.isFinite(value);
+        case "integer":
+            return Number.isInteger(value);
+        case "null":
+            return value === null;
+        case "array":
+            return isArgList(value);
+        case "object":
+            return isArgObject(value);
+    }
+};
+/** Whether two values are the same JSON, whatever order an object writes its fields in. */
+const isSameValue = (left, right) => {
+    if (Array.isArray(left) && Array.isArray(right))
+        return left.length === right.length && left.every((each, index) => isSameValue(each, right[index]));
+    if (!isRecord(left) || !isRecord(right))
+        return left === right;
+    const names = Object.keys(left);
+    return (names.length === Object.keys(right).length &&
+        names.every((name) => Object.hasOwn(right, name) && isSameValue(left[name], right[name])));
+};
+/** What is wrong with a value's own kind: its type and the values it may be. */
+const kindProblem = (schema, value, path) => {
+    const types = schema.type === undefined ? [] : [schema.type].flat();
+    if (types.length > 0 && !types.some((type) => isOfType(type, value)))
+        return `${path} must be of type ${types.join(" or ")}`;
+    if (schema.enum !== undefined && !schema.enum.some((each) => isSameValue(each, value)))
+        return `${path} must be one of ${JSON.stringify(schema.enum)}`;
+    return schema.const !== undefined && !isSameValue(schema.const, value)
+        ? `${path} must be ${JSON.stringify(schema.const)}`
+        : undefined;
+};
+/** What is wrong with a number or a text. */
+const leafProblem = (schema, value, path) => {
+    if (typeof value === "number") {
+        if (schema.minimum !== undefined && value < schema.minimum)
+            return `${path} must be at least ${schema.minimum}`;
+        if (schema.maximum !== undefined && value > schema.maximum)
+            return `${path} must be at most ${schema.maximum}`;
+    }
+    if (typeof value !== "string")
+        return undefined;
+    // in characters, as JSON Schema counts: an emoji is one
+    const { length } = [...value];
+    if (schema.minLength !== undefined && length < schema.minLength)
+        return `${path} must have at least ${schema.minLength} characters`;
+    if (schema.maxLength !== undefined && length > schema.maxLength)
+        return `${path} must have at most ${schema.maxLength} characters`;
+    return schema.pattern !== undefined && !new RegExp(schema.pattern, "u").test(value)
+        ? `${path} must match ${schema.pattern}`
+        : undefined;
+};
+/** What is wrong with a list. */
+const listProblem = (schema, value, path) => {
+    if (schema.minItems !== undefined && value.length < schema.minItems)
+        return `${path} must have at least ${schema.minItems} items`;
+    if (schema.maxItems !== undefined && value.length > schema.maxItems)
+        return `${path} must have at most ${schema.maxItems} items`;
+    const { items } = schema;
+    if (items === undefined)
+        return undefined;
+    return value
+        .map((item, index) => problemAt(items, item, `${path}[${index}]`))
+        .find((each) => each !== undefined);
+};
+/** What is wrong with an object. */
+const objectProblem = (schema, value, path) => {
+    const missing = (schema.required ?? []).find((name) => !Object.hasOwn(value, name));
+    if (missing !== undefined)
+        return `${path} must have ${missing}`;
+    for (const [name, each] of Object.entries(value)) {
+        const fieldPath = `${path}.${name}`;
+        const declared = schema.properties !== undefined && Object.hasOwn(schema.properties, name);
+        const field = declared ? schema.properties?.[name] : schema.additionalProperties;
+        if (field === false)
+            return `${fieldPath} is not a field it takes`;
+        const problem = isRecord(field) ? problemAt(field, each, fieldPath) : undefined;
+        if (problem !== undefined)
+            return problem;
+    }
+    return undefined;
+};
+/** What is wrong with a value, at a place in the whole. */
+const problemAt = (schema, value, path) => {
+    const problem = kindProblem(schema, value, path) ?? leafProblem(schema, value, path);
+    if (problem !== undefined)
+        return problem;
+    if (schema.anyOf !== undefined && schema.anyOf.every((each) => problemAt(each, value, path) !== undefined))
+        return `${path} fits none of its forms`;
+    if (isArgList(value))
+        return listProblem(schema, value, path);
+    return isArgObject(value) ? objectProblem(schema, value, path) : undefined;
+};
+/**
+ * What is wrong with a value, in a sentence.
+ *
+ * @param schema - the control's schema.
+ * @param value - the value.
+ * @returns the sentence; none when it fits.
+ */
+export const schemaProblem = (schema, value) => {
+    try {
+        return problemAt(schema, value, "the value");
+    }
+    catch (error) {
+        // a pattern that is no regular expression is the control's mistake: no value can be known to fit it
+        return error instanceof Error ? error.message : String(error);
+    }
+};

package/dist/src/valueShape.d.ts

@@ -0,0 +1,94 @@
+/**
+ * What a prop's value looks like when it is more than one text or number: an object's fields, a list's items, the
+ * members of a mixed union. Read from the component's types (`vite/shapeDocs.ts`) or from a story's own arg, it drives
+ * the panel's nested fields, the check on a link's values, the worst case and what agents read of a prop.
+ *
+ * @remarks
+ * A shape is plain JSON, so it crosses from the plugin to the page and reaches an agent as it is. A value that fits a
+ * shape is plain JSON too, so a link can hold it. What JSON cannot hold (a component, a function, a date) is a `named`
+ * leaf: only one of the source's `namedValues` can stand for it. `json` is the way out for what cannot be drawn as
+ * fields: any JSON value, typed by hand. This module holds what the first screen needs of a shape; what reads a value
+ * against one is `shapeValues.ts`, which loads with the first prop that has a shape. Pure.
+ *
+ * @module
+ */
+import type { ArgValue } from "./messages.ts";
+import type { NamedValues } from "./namedValues.ts";
+/** One field of an object's shape. */
+export type ShapeField = {
+    /** The field's name. */
+    readonly name: string;
+    /** What it holds. */
+    readonly shape: ValueShape;
+    /** Whether a value must give it. */
+    readonly isRequired: boolean;
+    /** Whether it may hold `null`. Left out when not. */
+    readonly isNullable?: true;
+    /** The first paragraph of its TSDoc; left out when it has none. */
+    readonly description?: string;
+};
+/** What a value looks like. */
+export type ValueShape = {
+    readonly kind: "text";
+} | {
+    readonly kind: "number";
+} | {
+    readonly kind: "boolean";
+    /** The one value it may hold, for one branch of a discriminated union. Left out when it takes both. */
+    readonly only?: boolean;
+} | {
+    /** One of these values. */
+    readonly kind: "choice";
+    /** The values, in the order of the type. */
+    readonly values: readonly (string | number)[];
+} | {
+    /** Any number of items of one shape. */
+    readonly kind: "list";
+    /** The items' shape. */
+    readonly of: ValueShape;
+} | {
+    /** A fixed number of items, each of its own shape (`[number, number]`). */
+    readonly kind: "tuple";
+    /** Each item's shape, in order. */
+    readonly items: readonly ValueShape[];
+} | {
+    /** Named fields. */
+    readonly kind: "object";
+    /** The fields, in the order of the source. */
+    readonly fields: readonly ShapeField[];
+} | {
+    /** Any names, each holding one shape (`Record<string, number>`). */
+    readonly kind: "record";
+    /** The values' shape. */
+    readonly of: ValueShape;
+} | {
+    /** One of several shapes, chosen first (`"sm" | number`). */
+    readonly kind: "union";
+    /** The shapes, in the order of the type. */
+    readonly of: readonly ValueShape[];
+} | {
+    /** What JSON cannot hold: one of the source's named values, under the type as the source writes it. */
+    readonly kind: "named";
+    /** The type, as `namedValues` lists it (`IconComponent`). */
+    readonly type: string;
+    /** Whether a plain text can be given too (a node). Left out when not. */
+    readonly canTakeText?: true;
+} | {
+    /** A moment: a `Date`, which the story receives as one (`DateArg`). */
+    readonly kind: "date";
+} | {
+    /** Any JSON: what fields cannot show. */
+    readonly kind: "json";
+} | {
+    /** What a story's own arg looks like, for an arg no type describes: read from it when it is needed. */
+    readonly kind: "like";
+    /** The story's own value. */
+    readonly value: ArgValue;
+};
+/**
+ * Whether the panel can give a shape a value at all: a required part the source names no value for leaves it no way.
+ *
+ * @param shape - the shape.
+ * @param namedValues - the source's named values.
+ */
+export declare const canSetShape: (shape: ValueShape, namedValues: NamedValues) => boolean;

package/dist/src/valueShape.js

@@ -0,0 +1,25 @@
+/**
+ * Whether the panel can give a shape a value at all: a required part the source names no value for leaves it no way.
+ *
+ * @param shape - the shape.
+ * @param namedValues - the source's named values.
+ */
+export const canSetShape = (shape, namedValues) => {
+    switch (shape.kind) {
+        case "named":
+            return (shape.canTakeText === true ||
+                (Object.hasOwn(namedValues, shape.type) && Object.keys(namedValues[shape.type] ?? {}).length > 0));
+        case "list":
+            return canSetShape(shape.of, namedValues);
+        case "record":
+            return canSetShape(shape.of, namedValues);
+        case "tuple":
+            return shape.items.every((item) => canSetShape(item, namedValues));
+        case "object":
+            return shape.fields.every((field) => !field.isRequired || canSetShape(field.shape, namedValues));
+        case "union":
+            return shape.of.some((member) => canSetShape(member, namedValues));
+        default:
+            return true;
+    }
+};

package/dist/src/viewState.d.ts

@@ -13,7 +13,7 @@
  * @module
  */
 import { type AudienceId } from "./audiences.ts";
-import type { CatalogueSettings } from "./catalogue.ts";
+import type { CatalogueSettings, PlaySwitch } from "./catalogue.ts";
 import { type DeviceChoice, type OrientationChoice } from "./deviceView.ts";
 import { type TouchChoice, type ViewSwitch } from "./switches.ts";
 /**
@@ -78,6 +78,11 @@ export type ViewState = {
     readonly device: DeviceChoice;
     /** How the device is held: the story's own default (`auto`), or one way. */
     readonly orientation: OrientationChoice;
+    /**
+     * Whether a story's play function runs when its frame opens. A frame's address says only `off`: one with no word plays,
+     * so a test, a check or a tool that opens a frame runs its story's play whatever a reader chose.
+     */
+    readonly play: PlaySwitch;
 };
 /** The part of the view a frame applies on its root without loading again, so the story keeps its state. */
 export type LiveView = Pick<ViewState, "switches" | "backdrop" | "text">;
@@ -94,7 +99,7 @@ export declare const isComparing: (view: ViewState) => boolean;
 /** Every tool, in the bar's order. */
 export declare const MEASURE_TOOLS: readonly MeasureTool[];
 /** What the view reads of a catalogue: its switches and the lists its values are checked against. */
-export type ViewCatalogue = Pick<CatalogueSettings, "switches" | "widthRange" | "zooms" | "textSizes" | "backdrops" | "tabs" | "ownControls" | "audience">;
+export type ViewCatalogue = Pick<CatalogueSettings, "switches" | "widthRange" | "zooms" | "textSizes" | "backdrops" | "tabs" | "ownControls" | "audience" | "readerPlay">;
 /**
  * A width kept in a catalogue's range, in whole pixels.
  *
@@ -135,7 +140,7 @@ export declare const defaultView: (catalogue: ViewCatalogue) => ViewState;
  * with another, or the link would open that one.
  * @returns the parameters, in a stable order.
  */
-export declare const viewParams: (view: ViewState, switches: readonly ViewSwitch[], defaultAudience?: AudienceId) => URLSearchParams;
+export declare const viewParams: (view: ViewState, switches: readonly ViewSwitch[], defaultAudience?: AudienceId, defaultPlay?: PlaySwitch) => URLSearchParams;
 /**
  * Whether one of the given controls' values is changed (a switch, the background, the style sheets, the text size;
  * the stage's width is not a view setting): the View menu's button shows a dot for the controls it holds, so a view

package/dist/src/viewState.js

@@ -14,11 +14,13 @@
  */
 import { AUDIENCE_IDS, DEFAULT_AUDIENCE } from "./audiences.js";
 import { DEVICE_PARAMETER, isDeviceId, isDeviceOrientation, ORIENTATION_PARAMETER } from "./deviceView.js";
-import { switchValueOf, switchWithRole } from "./switches.js";
+import { shownSwitches, switchValueOf, switchWithRole } from "./switches.js";
 /** The page's own colour: no backdrop drawn. */
 export const PLAIN_BACKDROP = "plain";
 /** Forgebook's own settings the compare view can set side by side. */
 export const OWN_COMPARE_AXES = ["text", "sheets"];
+/** The values of the play switch. */
+const PLAY_SWITCHES = ["on", "off"];
 /** The view without any change. */
 export const DEFAULT_VIEW = {
     switches: {},
@@ -34,7 +36,8 @@ export const DEFAULT_VIEW = {
     tools: [],
     audience: DEFAULT_AUDIENCE,
     device: "auto",
-    orientation: "auto"
+    orientation: "auto",
+    play: "on"
 };
 /** Every style sheet setting, in the menu's order. */
 export const SHEETS_CHOICES = ["full", "structure", "restyled"];
@@ -142,7 +145,8 @@ export const parseView = (search, catalogue) => {
         tools: toolsOf(params.get("tools")),
         audience: choice(shown("audience"), AUDIENCE_IDS, catalogue.audience),
         device: deviceChoice(params.get(DEVICE_PARAMETER)),
-        orientation: orientationChoice(params.get(ORIENTATION_PARAMETER))
+        orientation: orientationChoice(params.get(ORIENTATION_PARAMETER)),
+        play: choice(params.get("play"), PLAY_SWITCHES, catalogue.readerPlay)
     };
 };
 /**
@@ -180,6 +184,8 @@ const frameParams = (view, switches) => {
         params.set("text", String(view.text));
     if (language !== undefined)
         setSwitch(language);
+    if (view.play === "off")
+        params.set("play", "off");
     return params;
 };
 /**
@@ -191,8 +197,13 @@ const frameParams = (view, switches) => {
  * with another, or the link would open that one.
  * @returns the parameters, in a stable order.
  */
-export const viewParams = (view, switches, defaultAudience = DEFAULT_AUDIENCE) => {
+export const viewParams = (view, switches, defaultAudience = DEFAULT_AUDIENCE, defaultPlay = DEFAULT_VIEW.play) => {
     const params = frameParams(view, switches);
+    // the address says only what differs from the catalogue's default; the frames still hear `off`
+    if (view.play === defaultPlay)
+        params.delete("play");
+    else
+        params.set("play", view.play);
     if (isComparing(view))
         params.set("compare", view.compare.join(","));
     if (view.width !== DEFAULT_VIEW.width)
@@ -278,7 +289,7 @@ export const schemeOf = (view, switches) => {
     const scheme = switchWithRole(switches, "colorScheme");
     if (scheme === undefined)
         return "light";
-    return switchValueOf(scheme, view.switches[scheme.id])?.scheme ?? "light";
+    return switchValueOf(scheme, shownSwitches(view.switches, switches)[scheme.id])?.scheme ?? "light";
 };
 /**
  * Whether a view draws in the higher contrast: its contrast switch's value says so; never without one.
@@ -290,7 +301,7 @@ export const isMoreContrastOf = (view, switches) => {
     const contrast = switchWithRole(switches, "contrast");
     if (contrast === undefined)
         return false;
-    return switchValueOf(contrast, view.switches[contrast.id])?.isMore === true;
+    return switchValueOf(contrast, shownSwitches(view.switches, switches)[contrast.id])?.isMore === true;
 };
 /**
  * The language a view shows: the language switch's value, empty for the stories' own text.
@@ -300,7 +311,9 @@ export const isMoreContrastOf = (view, switches) => {
  */
 export const languageOf = (view, switches) => {
     const language = switchWithRole(switches, "language");
-    return language === undefined ? "" : (view.switches[language.id] ?? language.default);
+    return language === undefined
+        ? ""
+        : (shownSwitches(view.switches, switches)[language.id] ?? language.default);
 };
 /**
  * Whether a view simulates a finger.
@@ -341,11 +354,15 @@ export const withTouchOf = (view, from, choice) => {
  * @param view - the view's switches.
  * @param switches - the catalogue's switches.
  */
-export const codeGlobalsOf = (view, switches) => Object.fromEntries(switches
-    .filter((each) => each.apply.kind === "code" || each.role === "touch")
-    .map((each) => [each.id, view.switches[each.id] ?? each.default]));
+export const codeGlobalsOf = (view, switches) => {
+    const shown = shownSwitches(view.switches, switches);
+    return Object.fromEntries(switches
+        .filter((each) => each.apply.kind === "code" || each.role === "touch")
+        .map((each) => [each.id, shown[each.id] ?? each.default]));
+};
 /** The parameters only the shell reads: a frame's address leaves them out. */
 const SHELL_PARAMETERS = [
+    "tag",
     "compare",
     "width",
     "height",

package/dist/src/vite/adapter.d.ts

@@ -24,6 +24,8 @@ export type StoryComponent = {
      * can renew the docs.
      */
     readonly sources: readonly string[];
+    /** Whether its file exports it as its default, which an import then writes without braces; read for `forgebook new`. */
+    readonly isDefaultExport?: boolean;
 };
 /** What a framework reads of a story file: its component, `{ docs: { name: null } }` without one, or why it cannot. */
 export type StoryComponentResult = StoryComponent | {
@@ -35,6 +37,11 @@ export type StoryComponentResult = StoryComponent | {
  * @param storyFile - the story file's absolute path.
  */
 export type ExtractStoryComponent = (storyFile: string) => StoryComponentResult;
+/** What a catalogue tells an adapter of how much of the app's build it reads. */
+export type AdapterContext = {
+    /** Whether it reads the app's build at all: `false` with `appBuild: false`, when no project code of it may run. */
+    readonly readsAppBuild: boolean;
+};
 /** A framework, as the plugin uses it. */
 export type FrameworkAdapter = {
     /** The framework's name, as `forgebook-docs --framework` writes it (`react`). */
@@ -57,8 +64,12 @@ export type FrameworkAdapter = {
      * opens, since Vite's scanner cannot read pages that are generated; none by default.
      */
     readonly browserDependencies?: readonly string[];
-    /** The Vite plugins the framework needs in a catalogue (React's Fast Refresh); none by default. */
-    readonly vitePlugins?: () => Promise<readonly PluginOption[]>;
+    /**
+     * The Vite plugins the framework needs in a catalogue (React's Fast Refresh); none by default. Given what the catalogue
+     * reads of the app's build, for an adapter that reads more of it (Nuxt's modules); called with nothing by an older
+     * core.
+     */
+    readonly vitePlugins?: (context?: AdapterContext) => Promise<readonly PluginOption[]>;
     /** The framework's own kind of component file, for a framework whose components are not all TypeScript; none by default. */
     readonly componentFiles?: ComponentFiles;
     /**
@@ -73,6 +84,13 @@ export type FrameworkAdapter = {
      * program and leaves out the code Vite's plugins add to it (Angular's): an edit of its story files reloads the pages.
      */
     readonly redrawsEditedStories?: boolean;
+    /**
+     * Whether Forgebook compiles the JSX of the project's `.js` files with Vite's JSX options (`jsxInScripts.ts`), as
+     * Storybook's webpack builder lets a library write it: `true` for a framework whose JSX Vite's compiler writes
+     * (React's, Preact's). `false` by default: for one whose JSX is another compiler's (Solid's), or whose plugins compile
+     * such files themselves (React Native Web's, with Flow types).
+     */
+    readonly compilesJsxInScripts?: boolean;
 };
 /**
  * A framework's own kind of component file (Vue's `.vue`): what the plugin must know of a file that is not TypeScript,
@@ -98,12 +116,32 @@ export type StoryFileShape = {
 };
 /** Reads the component a file exports (`forgebook new`): the export named, or the file's only component. */
 export type ExtractFileComponent = (file: string, exportName?: string) => StoryComponentResult;
+/**
+ * One place the application draws a component, as `forgebook new` reads it: the props it gives with a value code can
+ * hold as it is (a literal, or a list or an object of literals), each written as source code.
+ */
+export type CallSite = {
+    /** The file that draws it, absolute. */
+    readonly file: string;
+    /** Each prop given a literal value, by name, as code (`"danger"`, `3`, `true`, `["a", "b"]`). */
+    readonly args: Readonly<Record<string, string>>;
+};
+/**
+ * Finds where an application draws a component.
+ *
+ * @param file - the component's file, absolute.
+ * @param name - the name the component is exported by (`default` for a default export).
+ * @returns the call sites, in the order of their files; a message when they cannot be read.
+ */
+export type ExtractCallSites = (file: string, name: string) => readonly CallSite[] | string;
 /** A framework's docs module, as the plugin and the commands load it. */
 export type DocsModule = {
     /** Reads a story file's component. */
     readonly extractStoryComponent: ExtractStoryComponent;
     /** Reads a component a file exports; none in a framework package that does not offer it yet. */
     readonly extractFileComponent?: ExtractFileComponent;
+    /** Finds where the application draws a component, for the values `forgebook new` writes; none when not offered. */
+    readonly extractCallSites?: ExtractCallSites;
     /** The module a story file imports its types from (`@forgebook/react`); none when not given. */
     readonly storyTypesModule?: string;
     /**

package/dist/src/vite/adapter.js

@@ -21,6 +21,7 @@ export const isDocsModule = (module) => typeof module === "object" &&
     "extractStoryComponent" in module &&
     typeof module.extractStoryComponent === "function" &&
     (!("extractFileComponent" in module) || typeof module.extractFileComponent === "function") &&
+    (!("extractCallSites" in module) || typeof module.extractCallSites === "function") &&
     (!("storyTypesModule" in module) || typeof module.storyTypesModule === "string") &&
     (!("storyFileShape" in module) || typeof module.storyFileShape === "function") &&
     (!("sourcesChanged" in module) || typeof module.sourcesChanged === "function");