@takeshape/ssg 11.143.2 → 11.154.1

package/dist/graphql/query.js

@@ -1,141 +0,0 @@
-import { Kind, parse, print, TypeInfo, visit, visitWithTypeInfo } from 'graphql';
-import { addQueryVariables, createArgument, createVariableDefinition, updateQuery, wrapQuery } from "./ast.js";
-export function getItemType(fieldType) {
-    return 'ofType' in fieldType ? fieldType.ofType : fieldType;
-}
-export function getFields(type) {
-    return 'getFields' in type ? type.getFields() : undefined;
-}
-function addId(node) {
-    const selections = node.selectionSet && node.selectionSet.selections;
-    if (selections &&
-        !selections.find((selection) => (selection.kind === 'Field' || selection.kind === 'FragmentSpread') && selection.name.value === '_id')) {
-        selections.push({
-            kind: Kind.FIELD,
-            name: {
-                kind: Kind.NAME,
-                value: '_id'
-            },
-            arguments: [],
-            directives: []
-        });
-        return node;
-    }
-}
-export function ensureIds(queryAst, schema) {
-    const typeInfo = new TypeInfo(schema);
-    const visitor = {
-        Field: {
-            enter(node) {
-                const fieldDef = typeInfo.getFieldDef();
-                if (fieldDef) {
-                    const type = getItemType(fieldDef.type);
-                    const fields = getFields(type);
-                    if (fields?._id) {
-                        return addId(node);
-                    }
-                }
-            }
-        }
-    };
-    return visit(queryAst, visitWithTypeInfo(typeInfo, visitor));
-}
-const addLocaleVariable = addQueryVariables.bind(null, [{ name: 'locale', type: 'String' }]);
-const wrapWithContext = wrapQuery.bind(null, 'withContext', [{ name: 'locale', value: 'locale' }]);
-export function wrapWithLocaleContext(ast) {
-    return wrapWithContext(addLocaleVariable(ast));
-}
-function unboxLocalizedResponse(res) {
-    return {
-        ...res,
-        data: res.data && res.data.withContext
-    };
-}
-export const FILTER_VAR_NAME = '__filter';
-export function addContentIdFilter(ast, schema) {
-    const typeInfo = new TypeInfo(schema);
-    let filterType;
-    const varsToRemove = new Set();
-    const visitor = {
-        Field: {
-            enter(node) {
-                const matches = /^get(.+)List$/.exec(node.name.value);
-                if (matches) {
-                    const fieldDef = typeInfo.getFieldDef();
-                    if (fieldDef) {
-                        const filterArgType = fieldDef.args.find((arg) => arg.name === 'filter');
-                        if (filterArgType) {
-                            filterType = filterArgType.type.toString();
-                            const filterArgAst = createArgument({
-                                name: 'filter',
-                                value: FILTER_VAR_NAME
-                            });
-                            return {
-                                ...node,
-                                arguments: node.arguments
-                                    ? node.arguments
-                                        .filter((arg) => {
-                                        if (arg.name.value === 'filter' && arg.value.kind === 'Variable') {
-                                            varsToRemove.add(arg.value.name.value);
-                                            return false;
-                                        }
-                                        return true;
-                                    })
-                                        .concat(filterArgAst)
-                                    : [filterArgAst]
-                            };
-                        }
-                    }
-                }
-            }
-        }
-    };
-    let updatedAst = visit(ast, visitWithTypeInfo(typeInfo, visitor));
-    if (filterType) {
-        const type = filterType;
-        updatedAst = updateQuery(updatedAst, (query) => {
-            const variableDef = createVariableDefinition({
-                name: FILTER_VAR_NAME,
-                type
-            });
-            return {
-                ...query,
-                variableDefinitions: query.variableDefinitions
-                    ? query.variableDefinitions
-                        .filter((def) => !varsToRemove.has(def.variable.name.value))
-                        .concat(variableDef)
-                    : [variableDef]
-            };
-        });
-    }
-    return {
-        ast: updatedAst,
-        varName: FILTER_VAR_NAME,
-        modified: Boolean(filterType)
-    };
-}
-export function withQueryTransforms(connector, schema, { locale, usage, contentId } = {}) {
-    return async (gqlParams, context) => {
-        const variables = { ...gqlParams.variables };
-        let queryAst = parse(gqlParams.query);
-        if (usage) {
-            queryAst = ensureIds(queryAst, schema);
-        }
-        if (context?.isPaginated && contentId) {
-            const { ast, modified, varName } = addContentIdFilter(queryAst, schema);
-            if (modified) {
-                queryAst = ast;
-                variables[varName] = { term: { _id: contentId } };
-            }
-        }
-        if (locale) {
-            variables.locale ||= locale;
-            queryAst = wrapWithLocaleContext(queryAst);
-        }
-        const res = await connector({
-            query: print(queryAst),
-            variables
-        });
-        return locale ? unboxLocalizedResponse(res) : res;
-    };
-}

package/dist/graphql/schema-connector-factory.d.ts

@@ -1,10 +0,0 @@
-import type { GraphQLConnector } from '../types.ts';
-type GraphQLConfig = {
-    type: string;
-    file?: string;
-    url?: string;
-    headers?: Record<string, string>;
-};
-export declare function getRemoteConnector(config: GraphQLConfig): GraphQLConnector;
-export declare function schemaConnectorFactory(cwd: string, config?: GraphQLConfig): Promise<GraphQLConnector>;
-export {};

package/dist/graphql/schema-connector-factory.js

@@ -1,90 +0,0 @@
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import path from 'node:path';
-import fse from 'fs-extra';
-import { formatError, graphql } from 'graphql';
-import fetch from 'node-fetch';
-import { connectorWithMigrations } from "./migrate.js";
-export function getRemoteConnector(config) {
-    const { url } = config;
-    if (!url) {
-        throw new Error('Invalid GraphQL config: missing url');
-    }
-    return async (params) => {
-        const res = await fetch(url, {
-            method: 'POST',
-            body: JSON.stringify(params),
-            headers: {
-                'Content-Type': 'application/json',
-                ...(config.headers ?? {})
-            }
-        });
-        if (res.ok) {
-            return res.json();
-        }
-        const text = await res.text();
-        throw new Error(`${res.statusText}: ${text}`);
-    };
-}
-function parseConfigJson(json) {
-    if (json.request) {
-        return {
-            type: 'request',
-            ...json.request
-        };
-    }
-    if (json['graphql-js']) {
-        return {
-            type: 'graphql-js',
-            file: json['graphql-js']
-        };
-    }
-    return null;
-}
-function readConfigFile(path) {
-    let json;
-    try {
-        json = JSON.parse(fse.readFileSync(`${path}/.graphqlrc`, 'utf-8'));
-    }
-    catch {
-        throw new Error('An error occurred loading .graphqlrc.');
-    }
-    const config = parseConfigJson(json);
-    if (config) {
-        return config;
-    }
-    throw new Error(`Invalid configuration file: ${JSON.stringify(json)}`);
-}
-export async function schemaConnectorFactory(cwd, config) {
-    config ??= readConfigFile(cwd);
-    let connector;
-    if (config.type === 'graphql-js' && config.file) {
-        const schema = await import(__rewriteRelativeImportExtension(path.join(cwd, config.file)));
-        connector = async (params) => {
-            const res = await graphql({
-                schema: schema.default || schema,
-                source: params.query,
-                rootValue: null,
-                contextValue: {},
-                variableValues: params.variables
-            });
-            return {
-                data: res.data,
-                errors: res.errors?.map(formatError)
-            };
-        };
-    }
-    if (config.type === 'request') {
-        connector = getRemoteConnector(config);
-    }
-    if (connector) {
-        return connectorWithMigrations(connector);
-    }
-    throw new Error('Could not create GraphQL connector - invalid configuration');
-}

package/dist/gzip.d.ts

@@ -1,3 +0,0 @@
-import type { RenderTemplate } from './types.ts';
-export type GzipInputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
-export default function gzipContents(renderTemplate: RenderTemplate): RenderTemplate;

package/dist/gzip.js

@@ -1,14 +0,0 @@
-import { shouldCompress } from '@takeshape/util';
-import { gzip } from '@takeshape/util/node';
-export default function gzipContents(renderTemplate) {
-    return async (path, template, context) => {
-        const item = await renderTemplate(path, template, context);
-        if (shouldCompress(item.path)) {
-            return {
-                path: item.path,
-                contents: await gzip(item.contents)
-            };
-        }
-        return item;
-    };
-}

package/dist/index.d.ts

@@ -1,6 +0,0 @@
-export * from './config.ts';
-export * from './errors/index.ts';
-export * from './files.ts';
-export { default as generate, generateRoute } from './generate/index.ts';
-export * from './graphql/index.ts';
-export * from './types.ts';

package/dist/index.js

@@ -1,6 +0,0 @@
-export * from "./config.js";
-export * from "./errors/index.js";
-export * from "./files.js";
-export { default as generate, generateRoute } from "./generate/index.js";
-export * from "./graphql/index.js";
-export * from "./types.js";

package/dist/nunjucks.d.ts

@@ -1,7 +0,0 @@
-import type { Config, SyncFileLoader } from './config.ts';
-import TemplateRenderError from './errors/template-render-error.ts';
-import type { RenderTemplate, Stats } from './types.ts';
-export declare function formatError(error: Error): TemplateRenderError;
-export type TemplateContext = Record<string, any>;
-export type NunjucksRender = (templateName: string, context: TemplateContext) => Promise<string>;
-export default function nunjucksFactory(fileLoader: SyncFileLoader, config: Config, stats: Stats): RenderTemplate;

package/dist/nunjucks.js

@@ -1,88 +0,0 @@
-import path from 'node:path';
-import { deepClone } from '@takeshape/util';
-import nunjucks from '@takeshape/vm-nunjucks';
-import TemplateRenderError from "./errors/template-render-error.js";
-import { intersectionFilter, unionFilter } from "./filters/array-filters.js";
-import codeFilter from "./filters/code-filter.js";
-import createAssetFilter from "./filters/create-asset-filter.js";
-import createDateFilter from "./filters/create-date-filter.js";
-import createImageFilter from "./filters/create-image-filter.js";
-import createNumberFilter from "./filters/create-number-filter.js";
-import createRouteFilter from "./filters/create-route-filter.js";
-import markdownFilter from "./filters/markdown-filter.js";
-import pluralizeFilter from "./filters/pluralize-filter.js";
-import { permalink } from "./paths.js";
-function parseLocation(line) {
-    const groups = /\(([^)]+)\)(?: \[Line (\d+)(?:, Column (\d+))?])?/.exec(line);
-    if (groups) {
-        return {
-            file: groups[1],
-            line: Number.parseInt(groups[2], 10),
-            column: Number.parseInt(groups[3], 10)
-        };
-    }
-}
-function stripMessage(message) {
-    return message.replace(/\s*(?:Error:)?\s*/, '');
-}
-export function formatError(error) {
-    const lines = error.message.split('\n');
-    const location = parseLocation(lines[0]);
-    const message = stripMessage(lines[lines.length - 1]);
-    return new TemplateRenderError(message, location);
-}
-class SyncLoader {
-    fileLoader;
-    constructor(fileLoader) {
-        this.async = false;
-        this.fileLoader = fileLoader;
-    }
-    getSource(name) {
-        const src = this.fileLoader(name);
-        return src === undefined ? undefined : { src, path: name, noCache: false };
-    }
-}
-// Manually promisify env.render instead of bluebird.promisify
-// vm-nunjucks uses vm2 which disallows access to object.prototype from
-// code outside the vm this causes bluebird.promisify to throw a proxy error
-function getNunjucksRender(env) {
-    return async (template, context) => new Promise((resolve, reject) => {
-        env.render(template, context, (error, str) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve(str ?? '');
-        });
-    });
-}
-export default function nunjucksFactory(fileLoader, config, stats) {
-    const loader = (filePath) => fileLoader(path.join(config.templatePath, filePath));
-    const templateLoader = new SyncLoader(loader);
-    const env = new nunjucks.Environment(templateLoader);
-    env.addFilter('date', createDateFilter(config));
-    env.addFilter('route', createRouteFilter(config, stats));
-    env.addFilter('md', markdownFilter);
-    const numberFilter = createNumberFilter(config);
-    env.addFilter('numberFormat', numberFilter);
-    env.addFilter('number', numberFilter);
-    env.addFilter('code', codeFilter);
-    env.addFilter('image', createImageFilter(config.imageBaseUrl, config.imageDefaults));
-    env.addFilter('asset', createAssetFilter(config.assetBaseUrl));
-    env.addFilter('intersection', intersectionFilter);
-    env.addFilter('union', unionFilter);
-    env.addFilter('pluralize', pluralizeFilter);
-    const render = getNunjucksRender(env);
-    return async (path, template, context) => {
-        try {
-            stats.pagesGenerated++;
-            return {
-                path: permalink(path),
-                contents: await render(template, deepClone(context))
-            };
-        }
-        catch (e) {
-            throw e instanceof TemplateRenderError ? e : formatError(e);
-        }
-    };
-}

package/dist/paths.d.ts

@@ -1,2 +0,0 @@
-export declare function permalink(pathStr: string): string;
-export declare function joinPath(...args: string[]): string;

package/dist/paths.js

@@ -1,10 +0,0 @@
-import path from 'node:path';
-export function permalink(pathStr) {
-    if (pathStr.includes('.')) {
-        return pathStr;
-    }
-    return path.join(pathStr, 'index.html');
-}
-export function joinPath(...args) {
-    return path.join('/', ...args.filter(Boolean));
-}

package/dist/resolve-context.d.ts

@@ -1,34 +0,0 @@
-import { type ContextConfig, type FileLoader, type GraphQLQueryConfig, type RouteConfig } from './config.ts';
-import type { Data, GraphQLConnector, Json, Stats } from './types.ts';
-export type ResolvedQueryConfig = {
-    source: string;
-} & GraphQLQueryConfig;
-export type ResolveContextParams = {
-    contextConfig: ContextConfig;
-    srcPath: string;
-    fileLoader: FileLoader;
-    connector: GraphQLConnector;
-    route?: RouteConfig;
-    stats?: Stats;
-};
-type HandlerParams = {
-    srcPath: string;
-    filePath: string;
-    variables?: Record<string, Json>;
-    fileLoader: FileLoader;
-    connector: GraphQLConnector;
-    route?: RouteConfig;
-    stats?: Stats;
-};
-export declare function getType(path: string): string | null;
-export type FileHandlerParams = Pick<HandlerParams, 'srcPath' | 'filePath' | 'fileLoader'>;
-export declare function handleJSON({ srcPath, filePath, fileLoader }: FileHandlerParams): Promise<Data>;
-export declare function handleYaml({ srcPath, filePath, fileLoader }: FileHandlerParams): Promise<Data>;
-export declare function handleGraphQL({ srcPath, filePath, variables, connector, fileLoader, route, stats }: HandlerParams): Promise<Data>;
-export declare function handleContextString(params: ResolveContextParams): Promise<Data | string>;
-export declare function resolveGraphQLConfig(config: ContextConfig, { fileLoader, srcPath }: {
-    fileLoader: FileLoader;
-    srcPath: string;
-}): Promise<ResolvedQueryConfig>;
-export default function resolveContext(contextParams: ResolveContextParams): Promise<Data>;
-export {};

package/dist/resolve-context.js

@@ -1,115 +0,0 @@
-import path from 'node:path';
-import BbPromise from 'bluebird';
-import yaml from 'js-yaml';
-import forEach from 'lodash/forEach.js';
-import { isGraphQLQueryConfig } from "./config.js";
-import GraphQLError from "./errors/graphql-error.js";
-import { recordContentUsage } from "./stats.js";
-export function getType(path) {
-    const matches = /\.(graphql|yml|yaml|json)$/.exec(path);
-    if (matches?.length) {
-        const type = matches[1];
-        return type === 'yml' ? 'yaml' : type;
-    }
-    return null;
-}
-function getPath(contextConfig) {
-    if (typeof contextConfig === 'string') {
-        return contextConfig;
-    }
-    if (isGraphQLQueryConfig(contextConfig)) {
-        return contextConfig.query;
-    }
-    throw new Error('Unable to find file path in context config');
-}
-export async function handleJSON({ srcPath, filePath, fileLoader }) {
-    return fileLoader(path.join(srcPath, filePath)).then(JSON.parse);
-}
-export async function handleYaml({ srcPath, filePath, fileLoader }) {
-    const file = await fileLoader(path.join(srcPath, filePath));
-    const loaded = yaml.safeLoad(file);
-    if (!loaded || typeof loaded === 'string') {
-        throw new Error('unable to load file');
-    }
-    return loaded;
-}
-export async function handleGraphQL({ srcPath, filePath, variables, connector, fileLoader, route, stats }) {
-    const queryPath = path.join(srcPath, filePath);
-    const query = await fileLoader(queryPath);
-    const res = await connector({ query, variables }, { stats, source: filePath });
-    if (res.errors) {
-        throw new GraphQLError(`An error occurred while resolving ${queryPath}`, res.errors);
-    }
-    const data = res.data;
-    if (route?.path && !route.paginate) {
-        recordContentUsage(stats, data, route.path);
-    }
-    return data;
-}
-export async function handleContextString(params) {
-    const { contextConfig, ...rest } = params;
-    const filePath = getPath(contextConfig);
-    const type = getType(filePath);
-    if (type === 'json') {
-        return handleJSON({ ...rest, filePath });
-    }
-    if (type === 'yaml') {
-        return handleYaml({ ...rest, filePath });
-    }
-    if (type === 'graphql') {
-        return handleGraphQL({ ...rest, filePath });
-    }
-    return filePath;
-}
-export async function resolveGraphQLConfig(config, { fileLoader, srcPath }) {
-    let source;
-    let variables;
-    if (typeof config === 'string') {
-        source = config;
-    }
-    else if (isGraphQLQueryConfig(config)) {
-        source = config.query;
-        variables = config.variables;
-    }
-    if (!source) {
-        throw new Error('Missing .graphql or .gql query file');
-    }
-    const filePath = path.join(srcPath, source);
-    const query = await fileLoader(filePath);
-    return {
-        source,
-        query,
-        variables
-    };
-}
-async function handleValue(contextParams) {
-    const { contextConfig, ...rest } = contextParams;
-    if (typeof contextConfig === 'string') {
-        return handleContextString(contextParams);
-    }
-    if (typeof contextConfig === 'object') {
-        if (isGraphQLQueryConfig(contextConfig)) {
-            return handleGraphQL({
-                ...rest,
-                filePath: contextConfig.query,
-                variables: contextConfig.variables
-            });
-        }
-        const context = {};
-        forEach(contextConfig, (value, key) => {
-            context[key] = handleValue({
-                ...rest,
-                contextConfig: value
-            });
-        });
-        return BbPromise.props(context);
-    }
-    return contextConfig;
-}
-function isObject(obj) {
-    return Boolean(obj) && typeof obj === 'object' && !Array.isArray(obj);
-}
-export default async function resolveContext(contextParams) {
-    const context = await handleValue(contextParams);
-    return isObject(context) ? context : {};
-}

package/dist/stats.d.ts

@@ -1,4 +0,0 @@
-import type { Data, Json, Stats } from './types.ts';
-export declare function generateWarning(stats: Stats | undefined, source: string, message: string): void;
-export declare function scrapeIds(obj: Json, depth?: number, result?: Array<[string, number]>): Array<[string, number]>;
-export declare function recordContentUsage(stats: Stats | undefined, data: Data, path: string): void;

package/dist/stats.js

@@ -1,39 +0,0 @@
-export function generateWarning(stats, source, message) {
-    if (stats) {
-        if (!Array.isArray(stats.warnings)) {
-            stats.warnings = [];
-        }
-        stats.warnings.push({ source, message });
-    }
-}
-export function scrapeIds(obj, depth = 1, result = []) {
-    if (Array.isArray(obj)) {
-        for (const item of obj) {
-            scrapeIds(item, depth, result);
-        }
-    }
-    else if (obj && typeof obj === 'object') {
-        const newDepth = depth + 1;
-        for (const key of Object.keys(obj)) {
-            const value = obj[key];
-            if (key === '_id' && typeof value === 'string') {
-                result.push([value, depth]);
-            }
-            else {
-                scrapeIds(value, newDepth, result);
-            }
-        }
-    }
-    return result;
-}
-export function recordContentUsage(stats, data, path) {
-    if (stats?.contentUsage) {
-        const { contentUsage } = stats;
-        const ids = scrapeIds(data);
-        for (const [id, depth] of ids) {
-            contentUsage[id] ||= {};
-            const prevDepth = contentUsage[id][path];
-            contentUsage[id][path] = prevDepth ? Math.min(depth, prevDepth) : depth;
-        }
-    }
-}

package/dist/types.d.ts

@@ -1,53 +0,0 @@
-import type { GraphQLFormattedError } from 'graphql';
-type ArrayType<T extends any[]> = T extends Array<infer U> ? U : never;
-export type WritableProps<T> = {
-    -readonly [P in keyof T]: T[P] extends any[] ? Array<WritableProps<ArrayType<T[P]>>> : WritableProps<T[P]>;
-};
-export type TemplateLocation = {
-    file: string;
-    line: number;
-    column: number;
-};
-export type JsonPrimitive = string | boolean | number | null;
-export interface JsonMap<A> extends Record<string, A> {
-}
-export type Json = JsonPrimitive | Json[] | JsonMap<Json>;
-export type Data = Record<string, any>;
-export type Warning = {
-    source: string;
-    message: string;
-};
-export type ContentUsage = Record<string, Record<string, number>>;
-export type Stats = {
-    warnings: Warning[];
-    pagesGenerated: number;
-    contentUsage?: ContentUsage;
-};
-export type TemplateContext = Record<string, Json>;
-export type RenderedPage = {
-    path: string;
-    contents: string | Buffer;
-};
-export type RenderedRoute = {
-    pages: RenderedPage[];
-    order: number;
-};
-export type RenderTemplate = (path: string, template: string, context: TemplateContext) => Promise<RenderedPage>;
-export type RenderTemplateDecorator = (renderTemplate: RenderTemplate) => RenderTemplate;
-export type GraphQLConnectorParams = {
-    query: string;
-    variables?: Data;
-    operationName?: string;
-};
-export type GraphQLConnectorContext = {
-    source?: string;
-    stats?: Stats;
-    applyMigrations?: boolean;
-    isPaginated?: boolean;
-};
-export type GraphQLResult = {
-    errors?: GraphQLFormattedError[];
-    data?: Record<string, any> | null;
-};
-export type GraphQLConnector = (params: GraphQLConnectorParams, context?: GraphQLConnectorContext) => Promise<GraphQLResult>;
-export {};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/util.d.ts

@@ -1,2 +0,0 @@
-export type Updater = (update: any) => any;
-export declare function updateIn(obj: any, path: string[], update: Updater): any;

package/dist/util.js

@@ -1,17 +0,0 @@
-export function updateIn(obj, path, update) {
-    const lastIndex = path.length - 1;
-    let current = obj;
-    for (let i = 0; i < path.length; i++) {
-        const key = path[i];
-        if (current[key] === undefined) {
-            break;
-        }
-        if (i === lastIndex) {
-            current[key] = update(current[key]);
-        }
-        else {
-            current = current[key];
-        }
-    }
-    return obj;
-}