@xlr-lib/xlr-utils 0.1.1--canary.9.190

package/types/type-checks.d.ts

@@ -0,0 +1,58 @@
+import type { NamedType, NamedTypeWithGenerics, NodeType, NodeTypeWithGenerics, PrimitiveTypes, StringType, NumberType, BooleanType, ObjectType, ArrayType, RefType, OrType, AndType, RecordType } from "@xlr-lib/xlr";
+/**
+ * Returns if the NodeType has generic tokens
+ */
+export declare function isGenericNodeType<T extends NodeType = NodeType>(nt: NodeType): nt is NodeTypeWithGenerics<T>;
+/**
+ * Returns if the named type has generic tokens
+ */
+export declare function isGenericNamedType<T extends NamedType = NamedType>(nt: NodeType): nt is NamedTypeWithGenerics<T>;
+/**
+ * Returns if the node is a `PrimitiveTypes`
+ */
+export declare function isPrimitiveTypeNode(node: NodeType): node is PrimitiveTypes;
+/**
+ * Type Guard for non-null values
+ */
+export declare function isNonNullable<T>(a: T | null | undefined): a is NonNullable<T>;
+/**
+ * Type guard for string type nodes
+ */
+export declare function isStringType(node: NodeType): node is StringType;
+/**
+ * Type guard for number type nodes
+ */
+export declare function isNumberType(node: NodeType): node is NumberType;
+/**
+ * Type guard for boolean type nodes
+ */
+export declare function isBooleanType(node: NodeType): node is BooleanType;
+/**
+ * Type guard for object type nodes
+ */
+export declare function isObjectType(node: NodeType): node is ObjectType;
+/**
+ * Type guard for array type nodes
+ */
+export declare function isArrayType(node: NodeType): node is ArrayType;
+/**
+ * Type guard for ref type nodes
+ */
+export declare function isRefType(node: NodeType): node is RefType;
+/**
+ * Type guard for or (union) type nodes
+ */
+export declare function isOrType(node: NodeType): node is OrType;
+/**
+ * Type guard for and (intersection) type nodes
+ */
+export declare function isAndType(node: NodeType): node is AndType;
+/**
+ * Type guard for record type nodes
+ */
+export declare function isRecordType(node: NodeType): node is RecordType;
+/**
+ * Type guard for named types (have name and source)
+ */
+export declare function isNamedType<T extends NodeType = NodeType>(node: NodeType): node is NamedType<T>;
+//# sourceMappingURL=type-checks.d.ts.map

package/types/validation-helpers.d.ts

@@ -0,0 +1,41 @@
+import type { Node } from "jsonc-parser";
+import type { ConditionalType, NodeType, ObjectType, RefNode } from "@xlr-lib/xlr";
+export interface PropertyNode {
+    /** Equivalent Property Name */
+    key: string;
+    /** Equivalent Property Value */
+    value: Node;
+}
+/**
+ * Takes a property node and returns the underlying Key/Value Pairs
+ */
+export declare function propertyToTuple(node: Node): PropertyNode;
+/**
+ * Turns a node's children into a map for easy access
+ */
+export declare function makePropertyMap(node: Node): Map<string, Node>;
+/**
+ * Checks if property is a leaf node or another node
+ */
+export declare function isNode(obj: Node | string | number | boolean): obj is Node;
+/**
+ * Computes if the first arg extends the second arg
+ */
+export declare function computeExtends(a: NodeType, b: NodeType): boolean;
+/**
+ * Attempts to resolve a conditional type
+ */
+export declare function resolveConditional(conditional: ConditionalType): NodeType;
+/**
+ * Resolve referenced node with potential generic arguments
+ */
+export declare function resolveReferenceNode(genericReference: RefNode, typeToFill: NodeType): NodeType;
+/**
+ * Combines two ObjectType objects to get a representation of the effective TypeScript interface of `base` extending `operand`
+ - * @param base The base interface
+ - * @param operand The interface that is extended
+ - * @param errorOnOverlap whether or not conflicting properties should throw an error or use the property from operand
+ - * @returns `ObjectType`
+ */
+export declare function computeEffectiveObject(base: ObjectType, operand: ObjectType, errorOnOverlap?: boolean): ObjectType;
+//# sourceMappingURL=validation-helpers.d.ts.map

package/types/xlr-helpers.d.ts

@@ -0,0 +1,13 @@
+import type { NodeType, OrType } from "@xlr-lib/xlr";
+/**
+ * Walks generics to fill in values from a combination of the default, constraint, and passed in map values
+ * TODO convert this to use simpleTransformGenerator
+ */
+export declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeType>, preferLocalGenerics?: boolean): NodeType;
+/** Applies the TS `Pick` or `Omit` type to an interface/union/intersection */
+export declare function applyPickOrOmitToNodeType(baseObject: NodeType, operation: "Pick" | "Omit", properties: Set<string>): NodeType | undefined;
+/** Applies the TS `Partial` or `Required` type to an interface/union/intersection */
+export declare function applyPartialOrRequiredToNodeType(baseObject: NodeType, modifier: boolean): NodeType;
+/** Applies the TS `Exclude` type to a union */
+export declare function applyExcludeToNodeType(baseObject: OrType, filters: NodeType | OrType): NodeType;
+//# sourceMappingURL=xlr-helpers.d.ts.map