@dotcms/client 0.0.1-alpha.4 → 0.0.1-alpha.41

package/src/lib/editor/utils/editor.utils.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Bound information for a contentlet.
+ *
+ * @interface ContentletBound
+ * @property {number} x - The x-coordinate of the contentlet.
+ * @property {number} y - The y-coordinate of the contentlet.
+ * @property {number} width - The width of the contentlet.
+ * @property {number} height - The height of the contentlet.
+ * @property {string} payload - The payload data of the contentlet in JSON format.
+ */
+interface ContentletBound {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    payload: string;
+}
+/**
+ * Bound information for a container.
+ *
+ * @interface ContainerBound
+ * @property {number} x - The x-coordinate of the container.
+ * @property {number} y - The y-coordinate of the container.
+ * @property {number} width - The width of the container.
+ * @property {number} height - The height of the container.
+ * @property {string} payload - The payload data of the container in JSON format.
+ * @property {ContentletBound[]} contentlets - An array of contentlets within the container.
+ */
+interface ContainerBound {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    payload: string;
+    contentlets: ContentletBound[];
+}
+/**
+ * Calculates the bounding information for each page element within the given containers.
+ *
+ * @export
+ * @param {HTMLDivElement[]} containers - An array of HTMLDivElement representing the containers.
+ * @return {ContainerBound[]} An array of objects containing the bounding information for each page element.
+ * @example
+ * ```ts
+ * const containers = document.querySelectorAll('.container');
+ * const bounds = getPageElementBound(containers);
+ * console.log(bounds);
+ * ```
+ */
+export declare function getPageElementBound(containers: HTMLDivElement[]): ContainerBound[];
+/**
+ * Calculates the bounding information for each contentlet inside a container.
+ *
+ * @export
+ * @param {DOMRect} containerRect - The bounding rectangle of the container.
+ * @param {HTMLDivElement[]} contentlets - An array of HTMLDivElement representing the contentlets.
+ * @return {ContentletBound[]} An array of objects containing the bounding information for each contentlet.
+ * @example
+ * ```ts
+ * const containerRect = container.getBoundingClientRect();
+ * const contentlets = container.querySelectorAll('.contentlet');
+ * const bounds = getContentletsBound(containerRect, contentlets);
+ * console.log(bounds); // Element bounds within the container
+ * ```
+ */
+export declare function getContentletsBound(containerRect: DOMRect, contentlets: HTMLDivElement[]): ContentletBound[];
+/**
+ * Get container data from VTLS.
+ *
+ * @export
+ * @param {HTMLElement} container - The container element.
+ * @return {object} An object containing the container data.
+ * @example
+ * ```ts
+ * const container = document.querySelector('.container');
+ * const data = getContainerData(container);
+ * console.log(data);
+ * ```
+ */
+export declare function getContainerData(container: HTMLElement): {
+    acceptTypes: string;
+    identifier: string;
+    maxContentlets: string;
+    uuid: string;
+};
+/**
+ * Get the closest container data from the contentlet.
+ *
+ * @export
+ * @param {Element} element - The contentlet element.
+ * @return {object | null} An object containing the closest container data or null if no container is found.
+ * @example
+ * ```ts
+ * const contentlet = document.querySelector('.contentlet');
+ * const data = getClosestContainerData(contentlet);
+ * console.log(data);
+ * ```
+ */
+export declare function getClosestContainerData(element: Element): {
+    acceptTypes: string;
+    identifier: string;
+    maxContentlets: string;
+    uuid: string;
+} | null;
+/**
+ * Find the closest contentlet element based on HTMLElement.
+ *
+ * @export
+ * @param {HTMLElement | null} element - The starting element.
+ * @return {HTMLElement | null} The closest contentlet element or null if not found.
+ * @example
+ * const element = document.querySelector('.some-element');
+ * const contentlet = findDotElement(element);
+ * console.log(contentlet);
+ */
+export declare function findDotElement(element: HTMLElement | null): HTMLElement | null;
+/**
+ * Find the closest VTL file element based on HTMLElement.
+ *
+ * @export
+ * @param {HTMLElement | null} element - The starting element.
+ * @return {HTMLElement | null} The closest VTL file element or null if not found.
+ * @example
+ * const element = document.querySelector('.some-element');
+ * const vtlFile = findDotVTLElement(element);
+ * console.log(vtlFile);
+ */
+export declare function findDotVTLElement(element: HTMLElement | null): HTMLElement | null;
+/**
+ * Find VTL data within a target element.
+ *
+ * @export
+ * @param {HTMLElement} target - The target element to search within.
+ * @return {Array<{ inode: string, name: string }> | null} An array of objects containing VTL data or null if none found.
+ * @example
+ * ```ts
+ * const target = document.querySelector('.target-element');
+ * const vtlData = findVTLData(target);
+ * console.log(vtlData);
+ * ```
+ */
+export declare function findVTLData(target: HTMLElement): {
+    inode: string | undefined;
+    name: string | undefined;
+}[] | null;
+/**
+ * Check if the scroll position is at the bottom of the page.
+ *
+ * @export
+ * @return {boolean} True if the scroll position is at the bottom, otherwise false.
+ * @example
+ * ```ts
+ * if (scrollIsInBottom()) {
+ *     console.log('Scrolled to the bottom');
+ * }
+ * ```
+ */
+export declare function scrollIsInBottom(): boolean;
+export {};

package/src/lib/query-builder/lucene-syntax/Equals.d.ts

@@ -0,0 +1,114 @@
+import { Field } from './Field';
+import { NotOperand } from './NotOperand';
+import { Operand } from './Operand';
+/**
+ * 'Equal' Is a Typescript class that provides the ability to use terms in the lucene query string.
+ * A term is a value used to search for a specific value in a document. It can be a word or a phrase.
+ *
+ * Ex: myValue or "My Value"
+ *
+ * @export
+ * @class Equal
+ */
+export declare class Equals {
+    #private;
+    private query;
+    constructor(query: string);
+    /**
+     * This method appends to the query a term that should be excluded in the search.
+     *
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.excludeField("myField2").equals("myValue2"); // Current query: "+myField: myValue -myField2: myValue2"
+     * ```
+     *
+     * @param {string} field - The field that should be excluded in the search.
+     * @return {*}  {Field} - An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof Equal
+     */
+    excludeField(field: string): Field;
+    /**
+     * This method appends to the query a field that should be included in the search.
+     *
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.field("myField2").equals("myValue2");  // Current query: "+myField: myValue +myField2: myValue2"
+     *```
+     * @param {string} field - The field that should be included in the search.
+     * @return {*}  {Field} - An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof Equal
+     */
+    field(field: string): Field;
+    /**
+     * This method appends to the query an operand to use logic operators in the query.
+     *
+     * @example
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.or().field("myField2").equals("myValue2"); // Current query: "+myField: myValue OR +myField2: myValue2"
+     * ```
+     *
+     * @return {*}  {Operand} - An instance of a Lucene Operand. An operand is a logical operator used to combine terms or phrases in a query.
+     * @memberof Equal
+     */
+    or(): Operand;
+    /**
+     * This method appends to the query an operand to use logic operators in the query.
+     *
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.and().field("myField2").equals("myValue2"); // Current query: "+myField: myValue AND +myField2: myValue2"
+     * ```
+     *
+     * @return {*}  {Operand} - An instance of a Lucene Operand. An operand is a logical operator used to combine terms or phrases in a query.
+     * @memberof Equal
+     */
+    and(): Operand;
+    /**
+     * This method appends to the query an operand to use logic operators in the query.
+     *
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.not().field("myField").equals("myValue2"); // Current query: "+myField: myValue NOT +myField: myValue2"
+     * ```
+     *
+     * @return {*}  {NotOperand} - An instance of a Lucene Not Operand. A not operand is a logical operator used to exclude terms or phrases in a query.
+     * @memberof Equal
+     */
+    not(): NotOperand;
+    /**
+     * This method allows to pass a raw query string to the query builder.
+     * This raw query should end in a Lucene Equal.
+     * This method is useful when you want to append a complex query or an already written query to the query builder.
+     *
+     * @example
+     * ```ts
+     * // This builds the follow raw query "+myField: value AND (someOtherValue OR anotherValue)"
+     * const equals = new Equals("+myField: value");
+     * equals.raw("+myField2: value2"); // Current query: "+myField: value +myField2: anotherValue"
+     * ```
+     *
+     * @param {string} query - A raw query string.
+     * @return {*}  {Equal} - An instance of a Lucene Equal. A term is a value used to search for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    raw(query: string): Equals;
+    /**
+     * This method returns the final query string.
+     *
+     * @example
+     * ```ts
+     * const equals = new Equals("+myField: myValue");
+     * equals.field("myField2").equals("myValue2").build(); // Returns "+myField: myValue +myField2: myValue2"
+     * ```
+     *
+     * @return {*}  {string} - The final query string.
+     * @memberof Equal
+     */
+    build(): string;
+}

package/src/lib/query-builder/lucene-syntax/Field.d.ts

@@ -0,0 +1,32 @@
+import { Equals } from './Equals';
+/**
+ * The `Field` class is used to build a query with a specific field.
+ * A Lucene Field is a key used to search for a specific value in a document.
+ *
+ * @export
+ * @class Field
+ */
+export declare class Field {
+    #private;
+    private query;
+    /**
+     * Creates an instance of the `Field` class.
+     *
+     * @param {string} query - The initial query string.
+     */
+    constructor(query: string);
+    /**
+     * Appends a term to the query that should be included in the search.
+     *
+     * @example
+     * ```typescript
+     * const field = new Field("+myField");
+     * field.equals("myValue");
+     * ```
+     *
+     * @param {string} term - The term that should be included in the search.
+     * @return {Equals} - An instance of `Equals`.
+     * @memberof Field
+     */
+    equals(term: string): Equals;
+}

package/src/lib/query-builder/lucene-syntax/NotOperand.d.ts

@@ -0,0 +1,26 @@
+import { Equals } from './Equals';
+/**
+ * 'NotOperand' Is a Typescript class that provides the ability to use the NOT operand in the lucene query string.
+ *
+ * @export
+ * @class NotOperand
+ */
+export declare class NotOperand {
+    #private;
+    private query;
+    constructor(query: string);
+    /**
+     * This method appends to the query a term that should be included in the search.
+     *
+     * @example
+     * ```typescript
+     * const notOperand = new NotOperand("+myField");
+     * notOperand.equals("myValue");
+     * ```
+     *
+     * @param {string} term - The term that should be included in the search.
+     * @return {*}  {Equals} - An instance of Equals.
+     * @memberof NotOperand
+     */
+    equals(term: string): Equals;
+}

package/src/lib/query-builder/lucene-syntax/Operand.d.ts

@@ -0,0 +1,44 @@
+import { Equals } from './Equals';
+import { Field } from './Field';
+/**
+ * 'Operand' Is a Typescript class that provides the ability to use operands in the lucene query string.}
+ * An operand is a logical operator used to join two or more conditions in a query.
+ *
+ * @export
+ * @class Operand
+ */
+export declare class Operand {
+    #private;
+    private query;
+    constructor(query: string);
+    /**
+     * This method appends to the query a term that should be excluded in the search.
+     *
+     * Ex: "-myValue"
+     *
+     * @param {string} field - The field that should be excluded in the search.
+     * @return {*}  {Field} - An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof Operand
+     */
+    excludeField(field: string): Field;
+    /**
+     * This method appends to the query a field that should be included in the search.
+     *
+     * Ex: "+myField:"
+     *
+     * @param {string} field - The field that should be included in the search.
+     * @return {*}  {Field} -  An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof Operand
+     */
+    field(field: string): Field;
+    /**
+     * This method appends to the query a term that should be included in the search.
+     *
+     * Ex: myValue or "My value"
+     *
+     * @param {string} term - The term that should be included in the search.
+     * @return {*}  {Equals} - An instance of Equals.
+     * @memberof Operand
+     */
+    equals(term: string): Equals;
+}

package/src/lib/query-builder/lucene-syntax/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Equals';
+export * from './Field';
+export * from './NotOperand';
+export * from './Operand';

package/src/lib/query-builder/sdk-query-builder.d.ts

@@ -0,0 +1,76 @@
+import { Equals, Field } from './lucene-syntax/index';
+/**
+ * 'QueryBuilder' Is a Typescript class that provides the ability to build a query string using the Lucene syntax in a more readable way.
+ * @example
+ * ```ts
+ *  const qb = new QueryBuilder();
+ *  const query = qb
+ *          .field('contentType')
+ *          .equals('Blog')
+ *          .field('conhost')
+ *          .equals('my-super-cool-site')
+ *          .build(); // Output: `+contentType:Blog +conhost:my-super-cool-site"`
+ * ```
+ *
+ * @example
+ * ```ts
+ *  const qb = new QueryBuilder();
+ *  const query = qb
+ *          .field('contentType')
+ *          .equals('Blog')
+ *          .field('title')
+ *          .equals('Football')
+ *          .excludeField('summary')
+ *          .equals('Lionel Messi')
+ *          .build(); // Output: `+contentType:Blog +title:Football -summary:"Lionel Messi"`
+ * ```
+ * @export
+ * @class QueryBuilder
+ */
+export declare class QueryBuilder {
+    #private;
+    /**
+     * This method appends to the query a field that should be included in the search.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.field("+myField: ", "myValue"); // Current query: "+myField: myValue"
+     * ```
+     *
+     * @param {string} field - The field that should be included in the search.
+     * @return {*}  {Field} -  An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    field(field: string): Field;
+    /**
+     * This method appends to the query a field that should be excluded from the search.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.excludeField("myField").equals("myValue"); // Current query: "-myField: myValue"
+     * ```
+     *
+     * @param {string} field - The field that should be excluded from the search.
+     * @return {*}  {Field} -  An instance of a Lucene Exclude Field. An exclude field is a key used to exclude for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    excludeField(field: string): Field;
+    /**
+     * This method allows to pass a raw query string to the query builder.
+     * This raw query should end in Equals.
+     * This method is useful when you want to append a complex query or an already written query to the query builder.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.raw("+myField: value AND (someOtherValue OR anotherValue)"); // Current query: "+myField: value AND (someOtherValue OR anotherValue)"
+     * ```
+     *
+     * @param {string} query - A raw query string.
+     * @return {*}  {Equals} - An instance of Equals. A term is a value used to search for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    raw(query: string): Equals;
+}

package/src/lib/query-builder/utils/index.d.ts

@@ -0,0 +1,142 @@
+import { Equals } from '../lucene-syntax/Equals';
+import { Field } from '../lucene-syntax/Field';
+import { NotOperand } from '../lucene-syntax/NotOperand';
+import { Operand } from '../lucene-syntax/Operand';
+/**
+ * Enum for common Operands
+ *
+ * @export
+ * @enum {number}
+ */
+export declare enum OPERAND {
+    OR = "OR",
+    AND = "AND",
+    NOT = "NOT"
+}
+/**
+ * This function removes extra spaces from a string.
+ *
+ * @example
+ * ```ts
+ * sanitizeQuery("  my query  "); // Output: "my query"
+ * ```
+ *
+ * @export
+ * @param {string} str
+ * @return {*}  {string}
+ */
+export declare function sanitizeQuery(str: string): string;
+/**
+ * This function sanitizes a term by adding quotes if it contains spaces.
+ * In lucene, a term with spaces should be enclosed in quotes.
+ *
+ * @example
+ * ```ts
+ * sanitizePhrases(`my term`); // Output: `"my term"`
+ * sanitizePhrases(`myterm`); // Output: `myterm`
+ * ```
+ *
+ * @export
+ * @param {string} term
+ * @return {*}  {string}
+ */
+export declare function sanitizePhrases(term: string): string;
+/**
+ * This function builds a term to be used in a lucene query.
+ * We need to sanitize the term before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const equals = buildEquals("+myField: ", "myValue"); // Current query: "+myField: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} term
+ * @return {*}  {Equals}
+ */
+export declare function buildEquals(query: string, term: string): Equals;
+/**
+ * This function builds a term to be used in a lucene query.
+ * We need to sanitize the raw query before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildRawEquals(query, "-myField2: myValue2"); // Current query: "+myField: myValue -myField2: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} raw
+ * @return {*}  {Equals}
+ */
+export declare function buildRawEquals(query: string, raw: string): Equals;
+/**
+ * This function builds a field to be used in a lucene query.
+ * We need to format the field before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const field = buildField("+myField: ", "myValue"); // Current query: "+myField: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} field
+ * @return {*}  {Field}
+ */
+export declare function buildField(query: string, field: string): Field;
+/**
+ * This function builds an exclude field to be used in a lucene query.
+ * We need to format the field before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildExcludeField(query, "myField2"); // Current query: "+myField: myValue -myField2:"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} field
+ * @return {*}  {Field}
+ */
+export declare function buildExcludeField(query: string, field: string): Field;
+/**
+ * This function builds an operand to be used in a lucene query.
+ * We need to format the operand before adding it to the query.
+ *
+ * @example
+ * <caption>E.g. Using the AND operand</caption>
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildOperand(query, OPERAND.AND); // Current query: "+myField: myValue AND"
+ * ```
+ * @example
+ * <caption>E.g. Using the OR operand</caption>
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildOperand(query, OPERAND.OR); // Current query: "+myField: myValue OR"
+ * ```
+ * @export
+ * @param {string} query
+ * @param {OPERAND} operand
+ * @return {*}  {Operand}
+ */
+export declare function buildOperand(query: string, operand: OPERAND): Operand;
+/**
+ * This function builds a NOT operand to be used in a lucene query.
+ * We need to format the operand before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildNotOperand(query); // Current query: "+myField: myValue NOT"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @return {*}  {NotOperand}
+ */
+export declare function buildNotOperand(query: string): NotOperand;

package/src/lib/utils/graphql/transforms.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents the response from a GraphQL query for a page.
+ *
+ * @interface GraphQLPageResponse
+ * @property {Record<string, unknown>} page - The main page data.
+ * @property {unknown} [key: string] - Additional properties that may be included in the response.
+ */
+interface GraphQLPageResponse {
+    page: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Transforms a GraphQL Page response to a Page Entity.
+ *
+ * @param {GraphQLPageResponse} graphQLPageResponse - The GraphQL Page response object.
+ * @returns {object|null} The transformed Page Entity or null if the page is not present.
+ *
+ * @example
+ * ```ts
+ * const pageEntity = graphqlToPageEntity(graphQLPageResponse);
+ * ```
+ */
+export declare const graphqlToPageEntity: (graphQLPageResponse: GraphQLPageResponse) => any;
+export {};

package/src/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './graphql/transforms';
+export * from './page/common-utils';

package/src/lib/utils/page/common-utils.d.ts

@@ -0,0 +1,33 @@
+import { PageApiOptions } from '../../client/sdk-js-client';
+/**
+ * Interface representing the properties for page request parameters.
+ *
+ * @export
+ * @interface PageRequestParamsProps
+ */
+export interface PageRequestParamsProps {
+    /**
+     * The API endpoint path.
+     * @type {string}
+     */
+    path: string;
+    /**
+     * The query parameters for the API request.
+     * Can be an object with key-value pairs or a URLSearchParams instance.
+     * @type {{ [key: string]: unknown } | URLSearchParams}
+     */
+    params: {
+        [key: string]: unknown;
+    } | URLSearchParams;
+}
+/**
+ * Generates the page request parameters to be used in the API call.
+ *
+ * @param {PageRequestParamsProps} PageRequestParamsProps - The properties for the page request.
+ * @returns {PageApiOptions} The options for the page API.
+ * @example
+ * ```ts
+ * const pageApiOptions = getPageRequestParams({ path: '/api/v1/page', params: queryParams });
+ * ```
+ */
+export declare const getPageRequestParams: ({ path, params }: PageRequestParamsProps) => PageApiOptions;

package/src/index.js

@@ -1,3 +0,0 @@
-export * from './lib/sdk-js-client';
-export * from './lib/postMessageToEditor';
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/sdk/client/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC"}