@conterra/ct-mapapps-typings 4.17.1-next.20240320050317 → 4.17.1-next.20240322050922

package/ct/store/Filter.d.ts

@@ -1,68 +1,3 @@
-/**
- * Metadata to describe a store.
- */
-interface Metadata {
-    /** Stores may contain arbitrary custom metadata information. */
-    readonly [k: string]: any;
-    /**
-     * Title of the store.
-     */
-    readonly title?: string;
-    /**
-     * Description of the store.
-     */
-    readonly description?: string;
-    /**
-     * Name of the display field.
-     * Used e.g. for search results to display items.
-     */
-    readonly displayField?: string;
-    /**
-     * Fields available in the store. These are mandatory.
-     */
-    readonly fields: readonly FieldData[];
-    /**
-     * Flag to indicate, if the store supports spatial operations.
-     * If set to 'true', this implicitly declares that the items have a 'geometry' field.
-     * Default is 'false'.
-     */
-    readonly supportsGeometry?: boolean;
-    /**
-     * Flag to indicate, if the store can react to the 'sort' option in queries.
-     * If this flag ommited, the default value is 'true'.
-     */
-    readonly supportsSorting?: boolean;
-    /**
-     * Indicates whether the store supports listening for changes in the underlying data.
-     * If this is true, `store.on("changed", ...)` must be implemented as well.
-     *
-     * Note that depending on the specific store, not all kinds of changes can be detected.
-     * For example, a store based on a feature layer might report client side edits, but may
-     * not report changes made to the service by other users.
-     */
-    readonly supportsChangedEvent?: boolean;
-}
-/**
- * List of well known field types.
- */
-type WellKnownFieldTypes = "string" | "number" | "date" | "geometry";
-/**
- * Field information in the store's metadata to describe a single field available in the store.
- */
-interface FieldData {
-    readonly [k: string]: any;
-    /** Name of the field. */
-    readonly name: string;
-    /** Title of the field. */
-    readonly title?: string;
-    /** Type of the field's value. */
-    readonly type: WellKnownFieldTypes | string;
-    /** If 'type' of the field is 'number', the 'precision' property indicates the kind of the number. */
-    readonly precision?: "single" | "double" | "long" | "float" | "smallinteger" | "biginteger" | "integer";
-    /** Marks a field as identity field. Should correlate with 'store.idProperty' */
-    readonly identifier?: boolean;
-}
-
 /**
  * A function to decorate a store with a predefined query.
  * This query will always be added to the queries against the decorated store.
@@ -71,8 +6,5 @@ interface FieldData {
  * The filter can be changed by using the setFilter method added to the store.
  */
 declare function Filter(store: any, filterQuery: any, filterOptions: any): any;
-declare namespace Filter {
-    function filterMetaData(...args: any[]): Metadata;
-}
 
 export { Filter as default };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@conterra/ct-mapapps-typings",
-    "version": "4.17.1-next.20240320050317",
+    "version": "4.17.1-next.20240322050922",
     "description": "TypeDefinitions for ct-mapapps",
     "author": "conterra",
     "license": "Apache-2.0"

package/store-api/utils.d.ts

@@ -68,7 +68,6 @@ declare function toQueryResult<T extends {}>(result: undefined): ResultItems<T>;
  * This function creates a new function which can be used to implement
  * a Store.query method by evaluating and filtering data available in an iterable, e.g. array.
  *
- * It is a replacement for 'ct/store/ComplexQueryEngine'
  *
  * @example
  * ```js

package/ct/store/ComplexMemory.d.ts

@@ -1,3 +0,0 @@
-declare const _default: any;
-
-export { _default as default };

package/ct/store/ComplexQuery.d.ts

@@ -1,2 +0,0 @@
-import ComplexQuery from 'store-api/ComplexQuery';
-export { default } from 'store-api/ComplexQuery';

package/ct/store/ComplexQueryEngine.d.ts

@@ -1,2 +0,0 @@
-import { createComplexQueryEngine } from 'store-api/utils';
-export { createComplexQueryEngine as default } from 'store-api/utils';

package/ct/store/ComplexQueryToRQL.d.ts

@@ -1,9 +0,0 @@
-import { toRQL, _operatorMapping } from 'store-api/rest/RQLStore';
-export { _operatorMapping, toRQL } from 'store-api/rest/RQLStore';
-
-declare namespace exports {
-    export { toRQL };
-    export { _operatorMapping };
-}
-
-export { exports as default };

package/ct/store/ComplexQueryToSQL.d.ts

@@ -1,10 +0,0 @@
-import { toSQLWhere, astToSQLWhere, _operatorMapping } from 'store-api/rest/ComplexQueryToSQL';
-export { _operatorMapping, astToSQLWhere, toSQLWhere } from 'store-api/rest/ComplexQueryToSQL';
-
-declare namespace exports {
-    export { toSQLWhere };
-    export { astToSQLWhere };
-    export { _operatorMapping };
-}
-
-export { exports as default };

package/ct/store/ComplexQueryToSolrQL.d.ts

@@ -1,502 +0,0 @@
-import * as store_api_rest_ComplexQueryToSolrQL from 'store-api/rest/ComplexQueryToSolrQL';
-import { toSolrQL, astToSolrQL, _operatorMapping } from 'store-api/rest/ComplexQueryToSolrQL';
-import Geometry from 'esri/geometry/Geometry';
-
-/**
- * Language specification of a ComplexQuery.
- *
- * @module
- */
-/** Expression to describe a ComplexQuery. */
-type ComplexQueryExpression = ShortAndExpression | LogicExpression;
-/**
- * Expression to provide a short way to specify an '$and' expression.
- *
- * ```js
- * { a: 1 , b: 3 }
- *
- * // this is the same like:
- * { $and: [{a: {$eq: 1}}, {b: {$eq:3}}]}
- * ```
- * @internal
- */
-interface ShortAndExpression {
-    /**
-     * Attribute that should match the condition.
-     */
-    readonly [attributeName: string]: SimpleValue | ValueOperatorExpression | LogicExpression;
-}
-/**
- * '$and' operator expression.
- * Logical 'and' that combines other expressions.
- *
- * ```js
- * { $and: [{a: {$eq: 1}}, {b: {$eq:3}}]}
- * ```
- * @internal
- */
-interface AndExpression {
-    /** Expression containing other expressions to be combined with 'and'. */
-    readonly $and: ReadonlyArray<ComplexQueryExpression>;
-}
-/**
- * '$or' operator expression.
- * Logical 'or' that combines other expressions.
- * ```js
- * { $or: [{a: {$eq: 1}}, {a: {$eq:2}}]}
- * ```
- * @internal
- */
-interface OrExpression {
-    /** Expression containing other expressions to be combined with 'or'. */
-    readonly $or: ReadonlyArray<ComplexQueryExpression>;
-}
-/**
- * '$nor' operator expression.
- * Logical 'negating or' expression.
- * Semantically the same as a `$not : { $or : [...] }` combination.
- *
- * ```js
- * { $nor: [{a: {$eq: 1}}, {a: {$eq:2}}]}
- * ```
- * @internal
- */
-interface NOrExpression {
-    /** Expression containing other expressions to be combined with 'negating or'. */
-    readonly $nor: ReadonlyArray<ComplexQueryExpression>;
-}
-/**
- * '$not' operator expression.
- * Logically negates another expression.
- *
- * ```js
- * { $not: {a: {$eq: 1} } }
- * ```
- * @internal
- */
-interface NotExpression {
-    /** Expression to be negated. */
-    readonly $not: ComplexQueryExpression;
-}
-/**
- * '$eq' operator expression.
- * Tests for an attribute to equal a given value.
- *
- * ```js
- * {a: {$eq: 1} }
- * ```
- * The short form is `{a: 1}`.
- * @internal
- */
-interface EqualsExpression {
-    /** Value to be checked against for equality. */
-    readonly $eq: SimpleValue;
-}
-/**
- * '$eqw' operator expression.
- * Tests for an attribute to match a wildcard expression.
- * Allowed wild cards are '*' (any char) and '?' (single char).
- *
- * ```js
- * {a: {$eqw: "H*lo"} }
- * ```
- * @internal
- */
-interface EqualsWildCardExpression {
-    /** The value containing the wild card. */
-    readonly $eqw: string;
-}
-/**
- * '$lt' operator expression.
- * Tests for an attribute to be lesser than a given value.
- *
- * ```js
- * {a: {$lt: 4} }
- * ```
- * @internal
- */
-interface LesserExpression {
-    /** Value to check against. */
-    readonly $lt: SimpleValue;
-}
-/**
- * '$lte' operator expression.
- * Tests for an attribute  to be lesser or equal to a given value.
- *
- * ```js
- * {a: {$lte: 4} }
- * ```
- * @internal
- */
-interface LesserOrEqualExpression {
-    /** Value to check against. */
-    readonly $lte: SimpleValue;
-}
-/**
- * '$gt' operator expression.
- * Tests for an attribute to be greater than a given value.
- *
- * ```js
- * {a: {$gt: 4} }
- * ```
- * @internal
- */
-interface GreaterExpression {
-    /** Value to check against. */
-    readonly $gt: SimpleValue;
-}
-/**
- * '$gte' operator expression.
- * Tests for an attribute to be greater or equal to a given value.
- *
- * ```js
- * {a: {$gte: 4} }
- * ```
- * @internal
- */
-interface GreaterOrEqual {
-    /** Value to check against. */
-    readonly $gte: SimpleValue;
-}
-/**
- * '$in' operator expression.
- * Tests for an attribute to be equal to at least one value in a list of values.
- *
- * ```js
- * {a: {$in: [1,2,3,4]} }
- * ```
- * This is semantically equivalent to:
- * ```js
- * {$or: [{a:{$eq:1}},{a:{$eq:2}},{a:{$eq:3}},{a:{$eq:4}}]}}
- * ```
- * @internal
- */
-interface InExpression {
-    /** List of values to check against. */
-    readonly $in: ReadonlyArray<SimpleValue>;
-}
-/**
- * '$nin' operator expression.
- * Tests for an attribute not to be equal to any of the values in a list of values.
- *
- * ```js
- * {a: {$nin: [1,2,3,4]} }
- * ```
- * This is semantically equivalent to:
- * ```js
- * {$not:{$or: [{a:{$eq:1}},{a:{$eq:2}},{a:{$eq:3}},{a:{$eq:4}}]}}}
- * ```
- * @internal
- */
-interface NotInExpression {
-    /** List of values to check against. */
-    readonly $nin: ReadonlyArray<SimpleValue>;
-}
-/**
- * '$neq' operator expression.
- * Tests for an attribute not to be equal to a value.
- *
- * ```js
- * {a: {$neq: 1} }
- * ```
- * This is semantically equivalent to:
- * ```js
- * {$not: {a: {$eq: 1}}}
- * ```
- * @internal
- */
-interface NotEqualExpression {
-    /** Value to check against. */
-    readonly $neq: SimpleValue;
-}
-/**
- * '$exists' operator expression.
- * Tests for an attribute to exist or not exist, depending on the boolean flag given.
- *
- * ```js
- * {a: {$exists: true} }
- * ```
- * @internal
- */
-interface ExistsExpression {
-    /** Flag to determine if a value exists or not. */
-    readonly $exists: boolean;
-}
-/**
- * '$suggest' operator expression.
- * Tests if an attribute value may be suggested by the given string.
- *
- * ```js
- * {a: {$suggest: "term"} }
- * ```
- * @internal
- */
-interface SuggestExpression {
-    /** Suggest term for an attribute value. */
-    readonly $suggest: string;
-}
-/**
- * '$elemMatch' operator expression.
- * Only valid if an attribute has an array as value.
- * Tests for at least one element in the array to fulfill the given expression.
- *
- * ```js
- * {a:{$elemMatch: {name:{$eq: "x"}}}}
- * ```
- * @internal
- */
-interface ElementMatchExpression {
-    /** Expression to check against. */
-    readonly $elemMatch: ReadonlyArray<ComplexQueryExpression>;
-}
-/**
- * '$intersects' spatial operator expression.
- * Operator matches if attribute `geometry` intersects the given geometry.
- *
- * ```js
- * { geometry : { $intersects: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialIntersectsExpression {
-    /** Test geometry */
-    readonly $intersects: Geometry;
-}
-/**
- * '$contains' spatial operator expression.
- *  Operator matches if attribute `geometry` is contained inside the given container geometry.
- *
- * ```js
- * { geometry : { $contains: containerGeometry }}
- * ```
- * @internal
- */
-interface SpatialContainsExpression {
-    /** Test geometry */
-    readonly $contains: Geometry;
-}
-/**
- * '$crosses' spatial operator expression.
- * Operator matches if attribute `geometry` crosses the other geometry.
- *
- * ```js
- * { geometry : { $crosses: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialCrossesExpression {
-    /** Test geometry */
-    readonly $crosses: Geometry;
-}
-/**
- * '$envelope-intersects' spatial operator expression.
- * Operator matches if envelope of attribute `geometry` intersects envelope of other geometry.
- *
- * ```js
- * { geometry : { $envelope-intersects: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialEnvelopeIntersectsExpression {
-    /** Test geometry */
-    readonly "$envelope-intersects": Geometry;
-}
-/**
- * '$overlaps' spatial operator expression.
- * Operator matches if attribute `geometry` overlaps the other geometry.
- *
- * ```js
- * { geometry : { $overlaps: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialOverlapsExpression {
-    /** Test geometry */
-    readonly "$overlaps": Geometry;
-}
-/**
- * '$touches' spatial operator expression.
- * Operator matches if attribute `geometry` touches the other geometry (share a common boundary).
- *
- * ```js
- * { geometry : { $touches: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialTouchesExpression {
-    /** Test geometry */
-    readonly "$touches": Geometry;
-}
-/**
- * '$within' spatial operator expression.
- * The opposite of `$contains`.
- *
- * Operator matches if attribute `geometry` contains the other geometry
- * (Alternative spelling: other geometry is within attribute `geometry`).
- *
- * ```js
- * { geometry : { $within: testGeometry }}
- * ```
- * @internal
- */
-interface SpatialWithinExpression {
-    /** Test geometry */
-    readonly "$within": Geometry;
-}
-/** Logical expressions to combine other expressions.
- * @internal
- */
-type LogicExpression = NotExpression | AndExpression | OrExpression | NOrExpression;
-type SpatialOperatorExpression = SpatialIntersectsExpression | SpatialContainsExpression | SpatialCrossesExpression | SpatialEnvelopeIntersectsExpression | SpatialOverlapsExpression | SpatialTouchesExpression | SpatialWithinExpression;
-/** Value operator expressions to check attribute values against.
- * @internal
- */
-type ValueOperatorExpression = EqualsExpression | EqualsWildCardExpression | LesserExpression | LesserOrEqualExpression | GreaterExpression | GreaterOrEqual | InExpression | NotInExpression | NotEqualExpression | ExistsExpression | SuggestExpression | ElementMatchExpression | SpatialOperatorExpression;
-/** Allowed types for simple values.
- * @internal
- */
-type SimpleValue = string | number | boolean | Date | RegExp | null | undefined | any[] | Record<string, any>;
-
-/**
- * Callback method that is triggered while walking over an AST.
- * @internal
- */
-type VisitCallback = (node: ASTNode, walker: Walker, childIndex: number, childrenCount: number) => void;
-/**
-  * Callback method that is triggered while walking over child nodes on an AST.
- * @internal
- */
-type ChildVisitCallback = (node: ASTNode, childIndex: number, childrenCount: number) => void;
-/**
- * Helper to analyze an AST.
- */
-interface Walker {
-    /** Root of the AST */
-    ROOT: ASTNode;
-    /** Global query options. */
-    queryOptions: ComplexQueryOptions;
-    /** All parents of the current node. */
-    parents: ASTNode[];
-    /** Index of the current node in the parent's children. */
-    currentIndex: number;
-    /** Current ASTNode. */
-    current: ASTNode;
-    /** Function to move the walker to the next sibling. */
-    toNextSibling(): Walker | undefined;
-    /** Function to move the walker to the previous sibling. */
-    toPrevSibling(): Walker | undefined;
-    /** Function to move the walker to a sibling with an offset relative to the current position. */
-    toSibling(offsetFromCurrentPosition: number): Walker | undefined;
-    /** Function to pick a sibling at an offset relative to the current position. */
-    sibling(offsetFromCurrentPosition: number): ASTNode | undefined;
-    /** Function to check if the next sibling exists. */
-    hasNextSibling(): boolean;
-    /** Function to check if the previous sibling exists. */
-    hasPrevSibling(): boolean;
-    /** Function to move the walker to the first child. */
-    toFirstChild(): Walker | undefined;
-    /** Function to move the walker to the last child. */
-    toLastChild(): Walker | undefined;
-    /** Function to move the walker to the child at a given index. */
-    toChild(childIndex: number): Walker | undefined;
-    /** Function to pick the child at a given index. */
-    child(childIndex: number): ASTNode | undefined;
-    /** Function to check if the child at a given index exists. */
-    hasChild(childIndex: number): boolean;
-    /** Function to check if the current node has children.  */
-    hasChildren(): boolean;
-    /** Function to move the walker to the current parent.   */
-    toParent(): Walker | undefined;
-    /** Function to check if the current node has a parent. */
-    hasParent(): boolean;
-    /** Function to move the walker to an ancestor with given an offset. e.g. 1=direct parent, 2 = grandparent, ... */
-    toAncestor(offset: number): Walker | undefined;
-    /** Function to move the walker to the AST root. */
-    toROOT(): Walker;
-    /** Function to pick the parent of the current node. */
-    parent(): ASTNode | undefined;
-    /** Function to pick the child nodes of the current node. */
-    children(): ASTNode[];
-    /** Function to get the number of children of the current node. */
-    childrenCount(): number;
-    /** Function to check if a given node is the root of the AST.
-     *  If no parameter is provided, this function will test if the walker is at the root position of the AST. */
-    isROOT(node?: ASTNode): boolean;
-    /** Function to create a new walker at the current node position. */
-    walker(): Walker;
-    /** Function to walk over all children. */
-    walkChildren(cb: ChildVisitCallback, scope?: any): void;
-    /** Function to walk over the AST.
-     *  The visitor callback is called once for every node.
-     *  Parents are visited before the children.
-     */
-    walkPreOrder(cb: VisitCallback, scope?: any): void;
-    /** Function to walk over the AST.
-     *  The visitor callback is called once for every node.
-     *  Parents are visited after the children.
-     */
-    walkPostOrder(cb: VisitCallback, scope?: any): void;
-    /** Function to walk over the AST.
-     *  The visitor callback is called twice for every node. */
-    walk(cb: VisitCallback, scope?: any): void;
-}
-/**
- * Node in the AST.
- */
-interface ASTNode {
-    /** Name of the operator. */
-    o: string;
-    /** Child nodes of this node. */
-    c?: ASTNode[];
-    /** Name of the left side attribute of the operator. */
-    n?: string;
-    /** Value of the right side of the operator. Can be an array of values. */
-    v?: any;
-    /** Value type (typeof v). Is an array if 'v' is an array, too. */
-    vt?: string[] | string;
-    /**  Indicate, if 'v' is an array. */
-    isArray?: boolean;
-}
-/**
- * Options used to modify a query or evaluation.
- */
-interface ComplexQueryOptions {
-    [k: string]: any;
-    ignoreCase?: boolean;
-    suggestContains?: boolean;
-}
-/**
- * AST representation of a complex query.
- */
-interface AST {
-    /**
-     * Query options used to parse the query.
-     */
-    queryOptions: ComplexQueryOptions;
-    /**
-     * Function to provide access to the root node.
-     */
-    root(): ASTNode | undefined;
-    /**
-     * Function to create a walker for easier visiting of nodes in the AST.
-     */
-    walker(): Walker;
-    /**
-     * Function to be called after modification of the AST to reduce
-     * useless '$and' or '$or' operators.
-     * @returns the optimized AST (not a copy!)
-     */
-    optimize(): AST;
-}
-
-declare function converter(ops: any): {
-    toSolrQL: (query?: ComplexQueryExpression | undefined, options?: store_api_rest_ComplexQueryToSolrQL.ComplexQueryToSolrQLOptions | undefined) => string;
-    astToSolrQL: (astOrWalker: Walker | AST) => string;
-};
-declare namespace converter {
-    export { toSolrQL };
-    export { astToSolrQL };
-    export { _operatorMapping };
-}
-
-export { converter as default };

package/ct/store/RQLStore.d.ts

@@ -1,2 +0,0 @@
-import { RQLStore } from 'store-api/rest/RQLStore';
-export { RQLStore as default } from 'store-api/rest/RQLStore';

package/ct/store/SQLStore.d.ts

@@ -1,2 +0,0 @@
-import { SQLStore } from 'store-api/rest/SQLStore';
-export { SQLStore as default } from 'store-api/rest/SQLStore';

package/ct/store/SpatialQuery.d.ts

@@ -1,2 +0,0 @@
-import SpatialQuery from 'store-api/SpatialQuery';
-export { default } from 'store-api/SpatialQuery';

package/ct/store/StoreUtil.d.ts

@@ -1,10 +0,0 @@
-import { sort, paginate, sortAndPaginate } from 'store-api/utils';
-export * from 'store-api/utils';
-
-declare namespace exports {
-    export { sort };
-    export { paginate };
-    export { sortAndPaginate };
-}
-
-export { exports as default };

package/ct/store/_RestStore.d.ts

@@ -1,2 +0,0 @@
-import { BaseWriteableRestStore } from 'store-api/rest/BaseWriteableRestStore';
-export { BaseWriteableRestStore as default } from 'store-api/rest/BaseWriteableRestStore';