@takeshape/schema 11.144.1 → 11.154.2

package/dist/util/expressions.d.ts

@@ -1,34 +0,0 @@
-import jsep, { type Expression } from 'jsep';
-export interface ObjectExpression extends Expression {
-    type: 'ObjectExpression';
-    properties: PropertyExpression[];
-}
-export interface PropertyExpression extends Expression {
-    type: 'Property';
-    computed: boolean;
-    key: AnyExpression;
-    value: AnyExpression;
-    shorthand: boolean;
-}
-type AnyExpression = jsep.ArrayExpression | jsep.BinaryExpression | jsep.MemberExpression | jsep.CallExpression | jsep.ConditionalExpression | jsep.Identifier | jsep.Literal | jsep.ThisExpression | jsep.UnaryExpression | ObjectExpression | PropertyExpression;
-export declare const METHODS_NOT_SUPPORTED = "Methods are not supported in expressions";
-export declare const THIS_NOT_SUPPORTED = "This is not supported in expressions";
-export declare function parseExpression(expression: string): AnyExpression;
-export type ExpressionContext = {
-    currentStateId: string;
-    previousStateId?: string;
-    currentStateOutput?: unknown;
-    sessionMemory: Record<string, unknown>;
-    claims: Record<string, unknown>;
-    args: Record<string, unknown>;
-    vars: Record<string, unknown>;
-};
-export declare function validateExpression(expression: string): {
-    valid: true;
-} | {
-    valid: false;
-    errors: string[];
-};
-export declare function compileExpression(expression: string): (context: Record<string, unknown>) => unknown;
-export declare function expressionToString(_node: jsep.Expression | null, parent?: AnyExpression): string;
-export {};

package/dist/util/expressions.js

@@ -1,350 +0,0 @@
-import object from '@jsep-plugin/object';
-import jsep from 'jsep';
-jsep.plugins.register(object);
-// Default operator precedence from https://github.com/EricSmekens/jsep/blob/master/src/jsep.js#L55
-const DEFAULT_PRECEDENCE = {
-    '||': 1,
-    '&&': 2,
-    '|': 3,
-    '^': 4,
-    '&': 5,
-    '==': 6,
-    '!=': 6,
-    '===': 6,
-    '!==': 6,
-    '<': 7,
-    '>': 7,
-    '<=': 7,
-    '>=': 7,
-    '<<': 8,
-    '>>': 8,
-    '>>>': 8,
-    '+': 9,
-    '-': 9,
-    '*': 10,
-    '/': 10,
-    '%': 10
-};
-/**
- * Evaluation code from JSEP project, under MIT License.
- * Copyright (c) 2013 Stephen Oney, http://jsep.from.so/
- */
-const binops = {
-    // '|'(a, b) {
-    //   return a | b;
-    // },
-    // '^'(a, b) {
-    //   return a ^ b;
-    // },
-    // '&'(a, b) {
-    //   return a & b;
-    // },
-    '=='(a, b) {
-        // biome-ignore lint/suspicious/noDoubleEquals: ignore
-        return a == b;
-    },
-    '!='(a, b) {
-        // biome-ignore lint/suspicious/noDoubleEquals: ignore
-        return a != b;
-    },
-    '==='(a, b) {
-        return a === b;
-    },
-    '!=='(a, b) {
-        return a !== b;
-    },
-    '<'(a, b) {
-        return a < b;
-    },
-    '>'(a, b) {
-        return a > b;
-    },
-    '<='(a, b) {
-        return a <= b;
-    },
-    '>='(a, b) {
-        return a >= b;
-    },
-    // '<<'(a, b) {
-    //   return a << b;
-    // },
-    // '>>'(a, b) {
-    //   return a >> b;
-    // },
-    // '>>>'(a, b) {
-    //   return a >>> b;
-    // },
-    '+'(a, b) {
-        return a + b;
-    },
-    '-'(a, b) {
-        return a - b;
-    },
-    '*'(a, b) {
-        return a * b;
-    },
-    '/'(a, b) {
-        return a / b;
-    },
-    '%'(a, b) {
-        return a % b;
-    }
-};
-const unops = {
-    '-'(a) {
-        return -a;
-    },
-    '+'(a) {
-        return Number(a);
-    },
-    // '~'(a) {
-    //   return ~a;
-    // },
-    '!'(a) {
-        return !a;
-    }
-};
-function evaluateArray(list, context) {
-    return list.map((v) => (v ? evaluate(v, context) : undefined));
-}
-function evaluateObject(properties, context) {
-    const obj = {};
-    for (const node of properties) {
-        const key = !node.computed && node.key.type === 'Identifier' ? node.key.name : evaluate(node.key, context);
-        obj[key] = evaluate(node.value, context);
-    }
-    return obj;
-}
-function isObject(x) {
-    return Boolean(x) && typeof x === 'object';
-}
-export const METHODS_NOT_SUPPORTED = 'Methods are not supported in expressions';
-export const THIS_NOT_SUPPORTED = 'This is not supported in expressions';
-function evaluateMember(node, context) {
-    const object = evaluate(node.object, context);
-    let key;
-    if (node.computed) {
-        key = evaluate(node.property, context);
-    }
-    else {
-        key = node.property.name;
-    }
-    if (typeof key === 'string' && /^__proto__|prototype|constructor$/.test(key)) {
-        throw Error(`Access to member "${key}" disallowed.`);
-    }
-    if (isObject(object) && Object.hasOwn(object, key)) {
-        return [object, object[key]];
-    }
-}
-function evaluate(_node, context) {
-    const node = _node;
-    switch (node.type) {
-        case 'ArrayExpression':
-            return evaluateArray(node.elements, context);
-        case 'ObjectExpression':
-            return evaluateObject(node.properties, context);
-        case 'CallExpression': {
-            if (node.callee.type === 'MemberExpression') {
-                throw Error(METHODS_NOT_SUPPORTED);
-            }
-            const fn = evaluate(node.callee, context);
-            if (typeof fn !== 'function') {
-                return undefined;
-            }
-            return fn.apply(null, evaluateArray(node.arguments, context));
-        }
-        case 'ConditionalExpression':
-            return evaluate(node.test, context) ? evaluate(node.consequent, context) : evaluate(node.alternate, context);
-        case 'Identifier':
-            return context[node.name];
-        case 'Literal':
-            return node.value;
-        case 'BinaryExpression': {
-            if (node.operator === '||') {
-                return evaluate(node.left, context) || evaluate(node.right, context);
-            }
-            if (node.operator === '&&') {
-                return evaluate(node.left, context) && evaluate(node.right, context);
-            }
-            const op = binops[node.operator];
-            if (!op) {
-                throw new Error(`Unsupported operator ${node.operator}`);
-            }
-            return op(evaluate(node.left, context), evaluate(node.right, context));
-        }
-        case 'UnaryExpression': {
-            const op = unops[node.operator];
-            if (!op) {
-                throw new Error(`Unsupported operator ${node.operator}`);
-            }
-            return op(evaluate(node.argument, context));
-        }
-        case 'MemberExpression':
-            return evaluateMember(node, context)?.[1];
-        case 'ThisExpression':
-            return context;
-        default:
-            return undefined;
-    }
-}
-export function parseExpression(expression) {
-    return jsep(expression);
-}
-function validateAST(options, rootNode) {
-    const validate = (_node, parent, parentKey) => {
-        const node = _node;
-        switch (node.type) {
-            case 'ArrayExpression':
-                return node.elements.flatMap((v) => (v ? validate(v, node, 'elements') : []));
-            case 'ObjectExpression':
-                return node.properties.flatMap((v) => validate(v, node, 'properties'));
-            case 'Property': {
-                {
-                    const keyErrors = !node.computed && node.key.type === 'Identifier' ? undefined : validate(node.key, node, 'key');
-                    const valueErrors = validate(node.value, node, 'value');
-                    return keyErrors ? [...keyErrors, ...valueErrors] : valueErrors;
-                }
-            }
-            case 'CallExpression': {
-                if (node.callee.type === 'MemberExpression') {
-                    return [{ message: METHODS_NOT_SUPPORTED }];
-                }
-                return [
-                    ...validate(node.callee, node, 'callee'),
-                    ...node.arguments.flatMap((v) => (v ? validate(v, node, 'arguments') : []))
-                ];
-            }
-            case 'ConditionalExpression':
-                return [
-                    ...validate(node.test, node, 'test'),
-                    ...validate(node.consequent, node, 'consequent'),
-                    ...validate(node.alternate, node, 'alternate')
-                ];
-            case 'Identifier': {
-                const errors = [];
-                if (parent?.type === 'CallExpression' && parentKey === 'callee' && options.allowedFunctions) {
-                    if (!options.allowedFunctions.includes(node.name)) {
-                        errors.push({ message: `Unknown function "${node.name}"` });
-                    }
-                }
-                else {
-                    if (parent?.type === 'MemberExpression' && !parent.computed && parentKey === 'property') {
-                        return errors;
-                    }
-                    if (options.allowedVars && !options.allowedVars.includes(node.name)) {
-                        errors.push({ message: `Unknown variable "${node.name}"` });
-                    }
-                }
-                return errors;
-            }
-            case 'Literal':
-                return [];
-            case 'BinaryExpression': {
-                const op = binops[node.operator];
-                if (!op) {
-                    throw new Error(`Unsupported operator ${node.operator}`);
-                }
-                return [...validate(node.left, node, 'left'), ...validate(node.right, node, 'right')];
-            }
-            case 'UnaryExpression': {
-                const op = unops[node.operator];
-                if (!op) {
-                    return [{ message: `Unsupported operator ${node.operator}` }];
-                }
-                return validate(node.argument, node, 'argument');
-            }
-            case 'MemberExpression':
-                return [
-                    ...validate(node.object, node, 'object'),
-                    ...(node.computed ? validate(node.property, node, 'property') : [])
-                ];
-            case 'ThisExpression':
-                return [{ message: THIS_NOT_SUPPORTED }];
-        }
-    };
-    return validate(rootNode, undefined, undefined);
-}
-const contextKeys = [
-    'currentStateId',
-    'previousStateId',
-    'currentStateOutput',
-    'sessionMemory',
-    'claims',
-    'args',
-    'vars'
-];
-export function validateExpression(expression) {
-    try {
-        const ast = parseExpression(expression);
-        const errors = validateAST({
-            allowedVars: contextKeys,
-            allowedFunctions: ['contains']
-        }, ast);
-        if (errors.length) {
-            return {
-                valid: false,
-                errors: errors.map((e) => e.message)
-            };
-        }
-        return { valid: true };
-    }
-    catch (e) {
-        return { valid: false, errors: [e.message] };
-    }
-}
-export function compileExpression(expression) {
-    const ast = parseExpression(expression);
-    return (context) => evaluate(ast, context);
-}
-export function expressionToString(_node, parent) {
-    if (!_node) {
-        return '';
-    }
-    const node = _node;
-    if (node.type === 'BinaryExpression') {
-        const wrap = parent?.type === 'BinaryExpression' && DEFAULT_PRECEDENCE[parent.operator] > DEFAULT_PRECEDENCE[node.operator];
-        const str = `${expressionToString(node.left, node)} ${node.operator} ${expressionToString(node.right, node)}`;
-        return wrap ? `(${str})` : str;
-    }
-    if (node.type === 'CallExpression') {
-        const args = node.arguments.map((arg) => expressionToString(arg, node));
-        return `${expressionToString(node.callee, node)}(${args.join(', ')})`;
-    }
-    if (node.type === 'UnaryExpression') {
-        return node.operator + expressionToString(node.argument, node);
-    }
-    if (node.type === 'MemberExpression') {
-        if (node.computed) {
-            return `${expressionToString(node.object, node)}[${expressionToString(node.property, node)}]`;
-        }
-        return `${expressionToString(node.object, node)}.${expressionToString(node.property, node)}`;
-    }
-    if (node.type === 'ArrayExpression') {
-        const arr = node.elements.map((element) => expressionToString(element, node)).join(',');
-        return `[${arr}]`;
-    }
-    if (node.type === 'Property') {
-        const keyStr = expressionToString(node.key, node);
-        if (node.shorthand) {
-            return keyStr;
-        }
-        return `${node.computed ? `[${keyStr}]` : keyStr}: ${expressionToString(node.value, node)}`;
-    }
-    if (node.type === 'ObjectExpression') {
-        const props = node.properties.map((element) => expressionToString(element, node)).join(',');
-        return `{ ${props} }`;
-    }
-    if (node.type === 'Literal') {
-        return node.raw;
-    }
-    if (node.type === 'Identifier') {
-        return node.name;
-    }
-    if (node.type === 'ConditionalExpression') {
-        return `${expressionToString(node.test, node)} ? ${expressionToString(node.consequent, node)} : ${expressionToString(node.alternate, node)}`;
-    }
-    if (node.type === 'ThisExpression') {
-        return 'this';
-    }
-    return '';
-}

package/dist/util/find-shape-at-path.d.ts

@@ -1,21 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, ShapeJSON } from '../project-schema/index.ts';
-/**
- *
- * @param projectSchema
- * @param schema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
- */
-export declare function findSchemaAtPath(projectSchema: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, schema: PropertySchema, queryPath: string[]): PropertySchema | undefined;
-/**
- *
- * @param projectSchema
- * @param propSchema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
- */
-export declare function findShapeAtPath(projectSchema: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, propSchema: PropertySchema, queryPath: string[]): ShapeJSON | undefined;

package/dist/util/find-shape-at-path.js

@@ -1,53 +0,0 @@
-import { getRef, refItemToShape, refItemToShapeSchema } from "../refs.js";
-import { isArraySchema, isObjectSchema, isRefSchema } from "../types/index.js";
-/**
- *
- * @param projectSchema
- * @param schema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds {'@ref': Shopify_Product}
- */
-export function findSchemaAtPath(projectSchema, schema, queryPath) {
-    if (queryPath.length === 0) {
-        return schema;
-    }
-    const [prop, ...rest] = queryPath;
-    if (isRefSchema(schema)) {
-        const ref = getRef(projectSchema, schema);
-        if (ref) {
-            const shapeSchema = refItemToShapeSchema(projectSchema, ref);
-            if (shapeSchema) {
-                return findSchemaAtPath(projectSchema, shapeSchema, queryPath);
-            }
-        }
-        return undefined;
-    }
-    if (isArraySchema(schema)) {
-        return findSchemaAtPath(projectSchema, schema.items, queryPath);
-    }
-    if (isObjectSchema(schema)) {
-        const propSchema = schema.properties[prop];
-        if (propSchema) {
-            return findSchemaAtPath(projectSchema, propSchema, rest);
-        }
-    }
-    return undefined;
-}
-/**
- *
- * @param projectSchema
- * @param propSchema
- * @param queryPath
- *
- * @example
- * findShapeAtPath(projectSchema, projectSchema.shapes.Shopify_ProductConnection.shape, ['edges', 'node']) // finds Shopify_Product
- */
-export function findShapeAtPath(projectSchema, propSchema, queryPath) {
-    const result = findSchemaAtPath(projectSchema, propSchema, queryPath);
-    if (result) {
-        const refItem = getRef(projectSchema, result.items ?? result);
-        return refItem && refItemToShape(projectSchema, refItem);
-    }
-}

package/dist/util/form-config.d.ts

@@ -1,11 +0,0 @@
-import { type Maybe } from '@takeshape/util';
-import type { FormConfig, FormMap, ProjectSchemaJSON } from '../project-schema/index.ts';
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-export declare function normalizeForms(projectSchema: ProjectSchemaJSON): FormMap;
-/**
- * Find the form config for a given shape name and the form key.
- */
-export declare function findShapeFormConfig(projectSchema: ProjectSchemaJSON, shapeName: string, formName: string): Maybe<FormConfig>;

package/dist/util/form-config.js

@@ -1,62 +0,0 @@
-import { deepClone } from '@takeshape/util';
-import { getRefOrItemsRef, refItemToNamespacedShapeName } from "../refs.js";
-import { createSchemaPropertyAccessor } from "../schema-util.js";
-/**
- * If there any non-normal (nested) forms in the schema, create forms for referenced shapes.
- * The original forms are left intact.
- */
-export function normalizeForms(projectSchema) {
-    const normalizedForms = {};
-    const { forms = {} } = projectSchema;
-    const storeSourceForm = (shapeName, formConfig, propName) => {
-        // Leave original forms intact for backwards compatibility
-        if (!forms[shapeName]) {
-            normalizedForms[shapeName] ||= { default: deepClone(formConfig) };
-            // Remove prop now that it has been normalized
-            delete normalizedForms[shapeName].default.properties[propName];
-        }
-    };
-    const normalizeNested = (shapeName, formConfig) => {
-        const shape = projectSchema.shapes[shapeName];
-        if (!shape || !formConfig.properties) {
-            return;
-        }
-        const propertyAccessor = createSchemaPropertyAccessor(projectSchema, shape);
-        for (const propName of Object.keys(formConfig.properties)) {
-            const propConfig = formConfig.properties[propName];
-            const propSchema = propertyAccessor.getValue(propName);
-            if (propSchema) {
-                const ref = getRefOrItemsRef(projectSchema, propSchema);
-                if (ref && propConfig.properties) {
-                    const nestedShapeName = refItemToNamespacedShapeName(projectSchema, ref);
-                    normalizedForms[nestedShapeName] = { default: deepClone(propConfig) };
-                    storeSourceForm(shapeName, formConfig, propName);
-                    normalizeNested(nestedShapeName, propConfig);
-                }
-            }
-        }
-    };
-    if (forms) {
-        for (const shapeName of Object.keys(forms)) {
-            normalizeNested(shapeName, forms[shapeName].default);
-            // copy forms with no changes
-            normalizedForms[shapeName] ||= forms[shapeName];
-        }
-    }
-    return normalizedForms;
-}
-const cache = new WeakMap();
-/**
- * Find the form config for a given shape name and the form key.
- */
-export function findShapeFormConfig(projectSchema, shapeName, formName) {
-    if (!projectSchema.forms) {
-        return;
-    }
-    let normalizedForms = cache.get(projectSchema);
-    if (!normalizedForms) {
-        normalizedForms = normalizeForms(projectSchema);
-        cache.set(projectSchema, normalizedForms);
-    }
-    return normalizedForms[shapeName]?.[formName];
-}

package/dist/util/get-conflicting-properties.d.ts

@@ -1,6 +0,0 @@
-import type { ShapeJSON } from '../project-schema/index.ts';
-import { type ServicesShapesContext } from '../refs.ts';
-/**
- * Given a list of shapes find the conflicting props
- */
-export declare function getConflictingProperties(context: ServicesShapesContext, shapes: ShapeJSON[]): Set<string>;

package/dist/util/get-conflicting-properties.js

@@ -1,55 +0,0 @@
-import { isDefined, setIsEqual } from '@takeshape/util';
-import { dereferenceSchema, getRef, serializeRef } from "../refs.js";
-import { isObjectSchema } from "../types/index.js";
-/**
- * Normalize ref, oneOf and array schemas and get a list of @ref expressions
- */
-function getRefStrings(context, propertySchema) {
-    const schema = propertySchema.items ?? propertySchema;
-    const schemas = schema.oneOf ? schema.oneOf : [schema];
-    return schemas
-        .map((propertySchema) => {
-        const ref = getRef(context, propertySchema);
-        return ref ? serializeRef(ref) : undefined;
-    })
-        .filter(isDefined);
-}
-function isRefEqual(context, a, b) {
-    return setIsEqual(getRefStrings(context, a), getRefStrings(context, b));
-}
-/**
- * Given a list of shapes find the conflicting props
- */
-export function getConflictingProperties(context, shapes) {
-    const conflicts = new Set();
-    const allProps = {};
-    for (const shape of Object.values(shapes)) {
-        const schema = dereferenceSchema(context, shape.schema, ['shapes', shape.name]);
-        if (!isObjectSchema(schema)) {
-            continue;
-        }
-        const required = new Set(schema.required ?? []);
-        for (const [name, prop] of Object.entries(schema.properties)) {
-            // skip props that we know already have  conflict
-            if (conflicts.has(name)) {
-                continue;
-            }
-            const isRequired = required.has(name);
-            if (allProps[name]) {
-                if (
-                // same type
-                allProps[name][0].type !== prop.type ||
-                    // same refs
-                    !isRefEqual(context, allProps[name][0], prop) ||
-                    // same nullability
-                    isRequired !== allProps[name][1]) {
-                    conflicts.add(name);
-                }
-            }
-            else {
-                allProps[name] = [prop, isRequired];
-            }
-        }
-    }
-    return conflicts;
-}

package/dist/util/get-return-shape.d.ts

@@ -1,4 +0,0 @@
-import type { ProjectSchemaJSON, PropertySchema, QueryJSON, ShapeJSON } from '../project-schema/index.ts';
-import { type ServicesShapesContext } from '../refs.ts';
-export declare function getReturnShapeRef(context: ServicesShapesContext, propOrQuery: PropertySchema | QueryJSON): import("@takeshape/util").Maybe<import("../refs.ts").RefItem>;
-export declare function getReturnShape(projectSchema: Pick<ProjectSchemaJSON, 'services' | 'shapes'>, propOrQuery: PropertySchema | QueryJSON): ShapeJSON | undefined;

package/dist/util/get-return-shape.js

@@ -1,30 +0,0 @@
-import { getRef, parseReturnShape, refItemToShape } from "../refs.js";
-function isQuery(propOrQuery) {
-    return 'shape' in propOrQuery && 'resolver' in propOrQuery;
-}
-function getReturnShapeHelper(projectSchema, propOrQuery) {
-    let shape;
-    if (isQuery(propOrQuery)) {
-        const { shapeName } = parseReturnShape(projectSchema, propOrQuery.shape);
-        shape = projectSchema.shapes[shapeName];
-    }
-    else {
-        const ref = getRef(projectSchema, propOrQuery);
-        if (ref) {
-            shape = refItemToShape(projectSchema, ref);
-        }
-    }
-    return shape;
-}
-export function getReturnShapeRef(context, propOrQuery) {
-    return isQuery(propOrQuery) ? parseReturnShape(context, propOrQuery.shape).ref : getRef(context, propOrQuery);
-}
-const cache = new WeakMap();
-export function getReturnShape(projectSchema, propOrQuery) {
-    let result = cache.get(propOrQuery);
-    if (result === undefined) {
-        result = getReturnShapeHelper(projectSchema, propOrQuery);
-        cache.set(propOrQuery, result ?? null);
-    }
-    return result ?? undefined;
-}

package/dist/util/has-arg.d.ts

@@ -1,6 +0,0 @@
-import type { Args, ObjectSchema, ProjectSchemaJSON } from '../project-schema/index.ts';
-import { type ServicesShapesContext } from '../refs.ts';
-import { type SchemaWithArgs } from '../types/index.ts';
-export declare function getArgs(prop: SchemaWithArgs): Args | undefined;
-export declare function getArgsSchema(projectSchema: ServicesShapesContext, args: Args): ObjectSchema | undefined;
-export declare function hasArg(projectSchema: ProjectSchemaJSON, prop: SchemaWithArgs, argPath: string | string[]): boolean;

package/dist/util/has-arg.js

@@ -1,25 +0,0 @@
-import { dereferenceObjectSchema, parseRef, refItemToShape } from "../refs.js";
-import { isObjectSchema } from "../types/index.js";
-import { findSchemaAtPath } from "./find-shape-at-path.js";
-export function getArgs(prop) {
-    return '@args' in prop ? prop['@args'] : 'args' in prop ? prop.args : undefined;
-}
-export function getArgsSchema(projectSchema, args) {
-    if (typeof args === 'object') {
-        return dereferenceObjectSchema(projectSchema, args);
-    }
-    const ref = parseRef(projectSchema, args);
-    const shapeSchema = refItemToShape(projectSchema, ref)?.schema;
-    if (shapeSchema && isObjectSchema(shapeSchema)) {
-        return shapeSchema;
-    }
-}
-export function hasArg(projectSchema, prop, argPath) {
-    const args = getArgs(prop);
-    if (!args) {
-        return false;
-    }
-    const schema = getArgsSchema(projectSchema, args);
-    const pathArray = Array.isArray(argPath) ? argPath : argPath.split('.');
-    return Boolean(schema && findSchemaAtPath(projectSchema, schema, pathArray));
-}

package/dist/util/is-asset-property.d.ts

@@ -1,3 +0,0 @@
-import type { PropertySchema } from '../project-schema/index.ts';
-export declare function isAssetProperty(prop: PropertySchema): boolean;
-export declare function isAssetRef(str: string): boolean;