@pristy/pristy-libvue 2.21.1 → 3.0.0

package/dist/src/services/AiMetadataService.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @param {Object} field a classification plan field
+ * @param {{dictionaries?: Array, lexicons?: Array}} sources
+ * @returns {?Object} the field as the Pristy Core endpoint describes it, or null when it cannot be suggested
+ */
+export function toFieldSpec(field: any, sources: {
+    dictionaries?: any[];
+    lexicons?: any[];
+}): any | null;
+/**
+ * @param {Object} options
+ * @param {Array<Object>} options.fields the plan fields shown in the form
+ * @param {Object} options.metadata the current form values, by field name
+ * @param {Set<string>} [options.disabledFields] fields the user cannot change, never sent
+ * @param {Array<string>} [options.requiredFields]
+ * @param {Array} [options.dictionaries]
+ * @param {Array} [options.lexicons]
+ * @param {string} [options.nature] the nature label
+ * @param {string} [options.locale]
+ * @returns {{nature: ?string, locale: string, fields: Array<Object>, values: Object}}
+ */
+export function buildSuggestionRequest({ fields, metadata, disabledFields, requiredFields, dictionaries, lexicons, nature, locale, }: {
+    fields: Array<any>;
+    metadata: any;
+    disabledFields?: Set<string>;
+    requiredFields?: Array<string>;
+    dictionaries?: any[];
+    lexicons?: any[];
+    nature?: string;
+    locale?: string;
+}): {
+    nature: string | null;
+    locale: string;
+    fields: Array<any>;
+    values: any;
+};
+/**
+ * @param {*} value a suggested value, as the endpoint returns it
+ * @param {Object} spec the field spec it was requested with
+ * @returns {*} the value in the shape the form inputs expect
+ */
+export function toFormValue(value: any, spec: any): any;
+/**
+ * @param {Object} request the request sent, see {@link buildSuggestionRequest}
+ * @param {Object} answer the endpoint answer
+ * @returns {Array<Object>} one row per suggested field, in form order: `name`, `label`, `spec`,
+ *   `current`, `proposed` (form shape), `kind`, `confidence`, `reason`, `accepted`
+ */
+export function buildReview(request: any, answer: any): Array<any>;
+/**
+ * @param {Object} metadata the current form values
+ * @param {Array<Object>} rows the reviewed rows, see {@link buildReview}
+ * @returns {{metadata: Object, applied: Set<string>}} the new form values and the fields changed
+ */
+export function applyAccepted(metadata: any, rows: Array<any>): {
+    metadata: any;
+    applied: Set<string>;
+};
+/**
+ * @param {*} value a current or proposed value
+ * @param {Object} spec its field spec
+ * @param {string} locale
+ * @returns {string} the value as shown to the user
+ */
+export function displayValue(value: any, spec: any, locale: string): string;
+/**
+ * @param {Error} error a rejection of {@link fetchSuggestions}
+ * @returns {string} the i18n key describing it
+ */
+export function errorKey(error: Error): string;
+/**
+ * @param {string} nodeId the document
+ * @param {Object} request see {@link buildSuggestionRequest}
+ * @returns {Promise<Object>} the endpoint answer; rejects with an Error carrying `status`
+ */
+export function fetchSuggestions(nodeId: string, request: any): Promise<any>;
+export const AI_METADATA_CAPABILITY: "ai.metadata-suggestions";
+export const KIND_FILL: "fill";
+export const KIND_CORRECTION: "correction";
+export const KIND_CONFIRMED: "confirmed";
+//# sourceMappingURL=AiMetadataService.d.ts.map

package/dist/src/services/AiMetadataService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AiMetadataService.d.ts","sourceRoot":"","sources":["../../../src/services/AiMetadataService.js"],"names":[],"mappings":"AA4GA;;;;GAIG;AACH,iDAHW;IAAC,YAAY,CAAC,QAAQ;IAAC,QAAQ,CAAC,QAAO;CAAC,GACtC,UAAO,CAyBnB;AAeD;;;;;;;;;;;GAWG;AACH,sIAVG;IAA+B,MAAM,EAA7B,KAAK,KAAQ;IACG,QAAQ;IACF,cAAc,GAApC,GAAG,CAAC,MAAM,CAAC;IACa,cAAc,GAAtC,KAAK,CAAC,MAAM,CAAC;IACG,YAAY;IACZ,QAAQ;IACP,MAAM,GAAvB,MAAM;IACW,MAAM,GAAvB,MAAM;CACd,GAAU;IAAC,MAAM,EAAG,MAAM,OAAA,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,KAAQ,CAAC;IAAC,MAAM,MAAQ;CAAC,CA2BpF;AAuCD;;;;GAIG;AACH,mCAJW,GAAC,cAEC,GAAC,CAoBb;AAED;;;;;GAKG;AACH,wDAHa,KAAK,KAAQ,CAiCzB;AAED;;;;GAIG;AACH,mDAHW,KAAK,KAAQ,GACX;IAAC,QAAQ,MAAS;IAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAC,CAYpD;AAED;;;;;GAKG;AACH,oCALW,GAAC,qBAED,MAAM,GACJ,MAAM,CA4BlB;AAED;;;GAGG;AACH,gCAHW,KAAK,GACH,MAAM,CAIlB;AAED;;;;GAIG;AACH,yCAJW,MAAM,iBAEJ,OAAO,KAAQ,CAoB3B;AAlWD,qCAAsC,yBAAyB,CAAC;AAEhE,wBAAyB,MAAM,CAAC;AAChC,8BAA+B,YAAY,CAAC;AAC5C,6BAA8B,WAAW,CAAC"}

package/dist/src/services/AlfrescoFileService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AlfrescoFileService.d.ts","sourceRoot":"","sources":["../../../src/services/AlfrescoFileService.js"],"names":[],"mappings":";;;AAiCA;;GAEG;AACH;IAEI,4BAGE;IAEF,4BAAkC;IAClC,qCAGE;IAEJ,kCAQC;IAED,gCAQC;IAED,gCAQC;IAED,uDAQC;IAED,mDAeC;IAED,2DAIC;IAED,8CASC;IAED;;;;;;;;;;;OAWG;IACH,yDAFa,OAAO,CAAC,GAAC,CAAC,CAkBtB;IAED,sEAeC;IAED,kFAIC;IAED,uHAEC;IAED;;;;;OAKG;IACH,+BAFW,KAAK,QAkBf;IAED;;;;;;OAMG;IACH,0BAHW,KAAK,mBAoCf;IAED,qCAYC;IAED;;;;;;OAMG;IACH,mDAHa,MAAM,GAAC,IAAI,CAMvB;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;;;OAMG;IACH,uEAsBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kDAFa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;OAQG;IACH,yEAFa,OAAO,CAAC,MAAM,CAAC,CAqB3B;IACD,qDAwCC;IACD,qCAMC;IACD,0BAOC;IACD,mCAqBC;IACD,wCAYC;IACD,sCA+BC;IACD,+EAcC;IACD,qBAEC;IACD,mBAEC;IACD,uBAEC;IACD,kCAqCC;IACD;;;;;;OAMG;IACH,+BALW,MAAM,QACN,MAAM,QACN,IAAI,gBAUd;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yBAdG;QAAqB,UAAU;QACV,UAAU;QAKT,UAAU;QACV,UAAU;QACV,UAAU;KAEhC,GAAU,MAAM,CAmBlB;IAED;;;;OAIG;IACH,qDAQC;CACF;qBA/lBoB,WAAW"}
+{"version":3,"file":"AlfrescoFileService.d.ts","sourceRoot":"","sources":["../../../src/services/AlfrescoFileService.js"],"names":[],"mappings":";;;AAiCA;;GAEG;AACH;IAEI,4BAGE;IAEF,4BAAkC;IAClC,qCAGE;IAEJ,kCAQC;IAED,gCAQC;IAED,gCAQC;IAED,uDAQC;IAED,mDAeC;IAED,2DAIC;IAED,8CASC;IAED;;;;;;;;;;;OAWG;IACH,yDAFa,OAAO,CAAC,GAAC,CAAC,CAkBtB;IAED,sEAeC;IAED,kFAIC;IAED,uHAEC;IAED;;;;;OAKG;IACH,+BAFW,KAAK,QAkBf;IAED;;;;;;OAMG;IACH,0BAHW,KAAK,mBAoCf;IAED,qCAaC;IAED;;;;;;OAMG;IACH,mDAHa,MAAM,GAAC,IAAI,CAMvB;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;;;OAMG;IACH,uEAsBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,kDAFa,OAAO,CAAC,MAAM,CAAC,CAkB3B;IAED;;;;;;;;OAQG;IACH,yEAFa,OAAO,CAAC,MAAM,CAAC,CAqB3B;IACD,qDAwCC;IACD,qCAMC;IACD,0BASC;IACD,mCAqBC;IACD,wCAYC;IACD,sCA+BC;IACD,+EAcC;IACD,qBAEC;IACD,mBAEC;IACD,uBAEC;IACD,kCAqCC;IACD;;;;;;OAMG;IACH,+BALW,MAAM,QACN,MAAM,QACN,IAAI,gBAUd;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yBAdG;QAAqB,UAAU;QACV,UAAU;QAKT,UAAU;QACV,UAAU;QACV,UAAU;KAEhC,GAAU,MAAM,CAmBlB;IAED;;;;OAIG;IACH,qDAQC;CACF;qBAlmBoB,WAAW"}

package/dist/src/services/ClassificationFileService.d.ts

@@ -1,3 +1,5 @@
+export const CONFLICT_VERSION: "version";
+export const CONFLICT_INCREMENT: "increment";
 declare const _default: ClassificationFileService;
 export default _default;
 /**
@@ -42,9 +44,21 @@ declare class ClassificationFileService {
      * @param {Object} metadata - New metadata properties
      * @param {string} newFileName - New file name (optional)
      * @param {Object} nature - Nature object with type and aspects
-     * @returns {Promise<Object>} The updated node
+     * @param {string} [destinationNodeId] - Root replacing the document library
+     * @param {?string} [onConflict] - What to do when the target folder already holds
+     *   that name: null throws a conflict error, {@link CONFLICT_INCREMENT} picks a free
+     *   name, {@link CONFLICT_VERSION} makes the document a new version of the existing one
+     * @returns {Promise<{targetFolderId: string, nodeId: string, name: string, replaced: boolean}>}
+     *   `nodeId` is the filed document: the existing one when it received a new version
+     * @throws {Error} with `conflict: true` and the conflicting `name` when no
+     *   `onConflict` is given and the name is taken
      */
-    requalifyDocument(nodeId: string, workspaceSiteId: string, pathFull: any[], metadata: any, newFileName: string, nature: any, destinationNodeId: any): Promise<any>;
+    requalifyDocument(nodeId: string, workspaceSiteId: string, pathFull: any[], metadata: any, newFileName: string, nature: any, destinationNodeId?: string, onConflict?: string | null): Promise<{
+        targetFolderId: string;
+        nodeId: string;
+        name: string;
+        replaced: boolean;
+    }>;
     /**
      * Uploads files with metadata according to a classification plan using the injector.
      * Delegates to the upload store to leverage worker-based implementation for better
@@ -56,5 +70,6 @@ declare class ClassificationFileService {
      * @param {Object[]} fileRenames Array of objects with original and new names.
      */
     uploadWithPlan(workspaceSiteId: string, pathFull: any[], files: File[], metadata: any, fileRenames: any[], destinationNodeId: any): Promise<void>;
+    #private;
 }
 //# sourceMappingURL=ClassificationFileService.d.ts.map

package/dist/src/services/ClassificationFileService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassificationFileService.d.ts","sourceRoot":"","sources":["../../../src/services/ClassificationFileService.js"],"names":[],"mappings":";;AAuBA;;;;GAIG;AACH;IACE;;;;;;;OAOG;IACH,gCAJW,MAAM,YACN,KAAQ,GACN,OAAO,CAAC,MAAM,CAAC,CA0C3B;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;;;;;;;OAUG;IACH,oCARW,MAAM,YACN,KAAQ,kBACR,MAAM,YACN,MAAM,uDAGJ,OAAO,KAAQ,CAoE3B;IAED;;;;;;;;;;OAUG;IACH,0BARW,MAAM,mBACN,MAAM,YACN,KAAQ,8BAER,MAAM,wCAEJ,OAAO,KAAQ,CA0C3B;IAED;;;;;;;;;OASG;IACH,gCANW,MAAM,YACN,KAAQ,SACR,IAAI,EAAE,8BAEN,KAAQ,yCAmBlB;CACF"}
+{"version":3,"file":"ClassificationFileService.d.ts","sourceRoot":"","sources":["../../../src/services/ClassificationFileService.js"],"names":[],"mappings":"AAuBA,+BAAgC,SAAS,CAAC;AAC1C,iCAAkC,WAAW,CAAC;;;AAI9C;;;;GAIG;AACH;IACE;;;;;;;OAOG;IACH,gCAJW,MAAM,YACN,KAAQ,GACN,OAAO,CAAC,MAAM,CAAC,CA0C3B;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAM3B;IAED;;;;;;;;;;OAUG;IACH,oCARW,MAAM,YACN,KAAQ,kBACR,MAAM,YACN,MAAM,uDAGJ,OAAO,KAAQ,CAoE3B;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,0BAfW,MAAM,mBACN,MAAM,YACN,KAAQ,8BAER,MAAM,mCAEN,MAAM,eACL,MAAM,OAAA,GAGL,OAAO,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,CAAC,CAmD9F;IAsCD;;;;;;;;;OASG;IACH,gCANW,MAAM,YACN,KAAQ,SACR,IAAI,EAAE,8BAEN,KAAQ,yCAmBlB;;CACF"}

package/dist/src/services/ClassificationService.d.ts

@@ -19,6 +19,11 @@ declare class ClassificationService {
      * @returns {Promise<string[]>} A promise that resolves with an array of filenames.
      */
     listPlans(): Promise<string[]>;
+    /**
+     * @param {string} filename The name of the plan file.
+     * @returns {Promise<?string>} the node id of the plan file, or null when it does not exist
+     */
+    getPlanNodeId(filename: string): Promise<string | null>;
     /**
      * Fetches a classification plan along with its allowableOperations.
      * @param {string} filename The name of the plan file.

package/dist/src/services/ClassificationService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassificationService.d.ts","sourceRoot":"","sources":["../../../src/services/ClassificationService.js"],"names":[],"mappings":";;AAuBA;IACE;;;;OAIG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAOxB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;OAGG;IACH,aAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAU7B;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,CAAC;QAAC,OAAO,EAAE,GAAG,CAAC;QAAC,mBAAmB,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,CAUlE;IAED;;;;;;OAMG;IACH,mBAFa,OAAO,CAAC,KAAQ,CAAC,CAwB7B;;CAuBF"}
+{"version":3,"file":"ClassificationService.d.ts","sourceRoot":"","sources":["../../../src/services/ClassificationService.js"],"names":[],"mappings":";;AAuBA;IACE;;;;OAIG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAOxB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CASzB;IAED;;;OAGG;IACH,aAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAU7B;IAED;;;OAGG;IACH,wBAHW,MAAM,GACJ,OAAO,CAAE,MAAM,OAAA,CAAC,CAK5B;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACJ,OAAO,CAAC;QAAC,OAAO,EAAE,GAAG,CAAC;QAAC,mBAAmB,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,CAUlE;IAED;;;;;;OAMG;IACH,mBAFa,OAAO,CAAC,KAAQ,CAAC,CAwB7B;;CAyBF"}

package/dist/src/services/ErrorService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ErrorService.d.ts","sourceRoot":"","sources":["../../../src/services/ErrorService.js"],"names":[],"mappings":"AAoFA;;;;;;;;;;;GAWG;AACH,uCATW,MAAM,SAEd;IAAsB,MAAM,EAApB,MAAM;IACS,QAAQ,GAC/B;QAAgC,KAAK,GACrC;YAAsC,OAAO,GAArC,MAAM;SACd;KAAA;IAA6B,OAAO,EAA5B,MAAM,MAAO;CACrB,GAAS,WAAW,CAgCtB;AAoFD,2CAyCC;;;AAvOD;;;;;GAKG;AACH;IACE,iDAIC;IAFC,UAAgB;IAChB,WAAkB;CAErB;AAgGD;;;;;GAKG;AACH;IACE,kCAwBC;IAED,iDAUC;IAED,6CAcC;IAED,uCAkBC;CACF"}
+{"version":3,"file":"ErrorService.d.ts","sourceRoot":"","sources":["../../../src/services/ErrorService.js"],"names":[],"mappings":"AAwFA;;;;;;;;;;;GAWG;AACH,uCATW,MAAM,SAEd;IAAsB,MAAM,EAApB,MAAM;IACS,QAAQ,GAC/B;QAAgC,KAAK,GACrC;YAAsC,OAAO,GAArC,MAAM;SACd;KAAA;IAA6B,OAAO,EAA5B,MAAM,MAAO;CACrB,GAAS,WAAW,CAgCtB;AAoFD,2CAyCC;;;AA3OD;;;;;GAKG;AACH;IACE,iDAIC;IAFC,UAAgB;IAChB,WAAkB;CAErB;AAoGD;;;;;GAKG;AACH;IACE,kCAwBC;IAED,iDAUC;IAED,6CAcC;IAED,uCAkBC;CACF"}

package/dist/src/services/IconeService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IconeService.d.ts","sourceRoot":"","sources":["../../../src/services/IconeService.js"],"names":[],"mappings":";;AAoBA;;;GAGG;AACH;IACE,2BA6LC;IAED,6BA2HC;CACF"}
+{"version":3,"file":"IconeService.d.ts","sourceRoot":"","sources":["../../../src/services/IconeService.js"],"names":[],"mappings":";;AAoBA;;;GAGG;AACH;IACE,2BA8LC;IAED,6BA4HC;CACF"}

package/dist/src/services/IndexAwaitService.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @param {?string} base the Alfresco host, `ALFRESCO_HOST`; the page origin when empty
+ * @returns {string} the `ws(s)://` URL of the index await socket
+ */
+export function indexAwaitSocketUrl(base: string | null): string;
+/**
+ * @param {*} nodeIds
+ * @returns {string[]} the non-empty string ids, each once, in their first order
+ */
+export function uniqueNodeIds(nodeIds: any): string[];
+/**
+ * @param {string[]} nodeIds
+ * @param {number} [size]
+ * @returns {string[][]} consecutive slices of at most `size` ids
+ */
+export function splitBatches(nodeIds: string[], size?: number): string[][];
+export { INDEX_AWAIT_STATUS } from '../../utils/indexAwaitReducer.js';
+export const INDEX_AWAIT_CAPABILITY: "solr.index-await";
+export const INDEX_AWAIT_SOCKET_PATH: "/alfresco/pristy-ws/index-await";
+export const DEFAULT_TIMEOUT: 20000;
+export const CLOSE_MARGIN: 5000;
+export const MAX_BATCH: 1000;
+export const LISTING_SOURCE: Readonly<{
+    DB: "db";
+    SEARCH: "search";
+}>;
+declare const _default: IndexAwaitService;
+export default _default;
+/**
+ * Waits until nodes are returned by a search, through the Pristy Core
+ * `index-await` WebSocket. See `docs/IndexAwait.md`.
+ */
+declare class IndexAwaitService {
+    /**
+     * @returns {Promise<boolean>} true when the Pristy Core announces `solr.index-await`
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * @param {string[]} nodeIds node UUIDs of `workspace://SpacesStore`
+     * @param {{timeout?: number, onProgress?: function({done: number, total: number}): void}} [options]
+     * @returns {Promise<{status: string, searchable: string[], errors: Array<{nodeId: string, verdict: ?string}>, rejected: string[], pending: string[]}>}
+     *   never rejects; `status` is `done`, `timeout` or `unavailable`
+     */
+    awaitSearchable(nodeIds: string[], { timeout, onProgress }?: {
+        timeout?: number;
+        onProgress?: (arg0: {
+            done: number;
+            total: number;
+        }) => void;
+    }): Promise<{
+        status: string;
+        searchable: string[];
+        errors: Array<{
+            nodeId: string;
+            verdict: string | null;
+        }>;
+        rejected: string[];
+        pending: string[];
+    }>;
+}
+//# sourceMappingURL=IndexAwaitService.d.ts.map

package/dist/src/services/IndexAwaitService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexAwaitService.d.ts","sourceRoot":"","sources":["../../../src/services/IndexAwaitService.js"],"names":[],"mappings":"AA6CA;;;GAGG;AACH,0CAHY,MAAM,OAAA,GACL,MAAM,CAMlB;AAED;;;GAGG;AACH,uCAHW,GAAC,GACC,MAAM,EAAE,CASpB;AAED;;;;GAIG;AACH,sCAJW,MAAM,EAAE,SACR,MAAM,GACJ,MAAM,EAAE,EAAE,CAQtB;;AAjDD,qCAAsC,kBAAkB,CAAC;AACzD,sCAAuC,iCAAiC,CAAC;AACzE,8BAA+B,KAAK,CAAC;AACrC,2BAA4B,IAAI,CAAC;AACjC,wBAAyB,IAAI,CAAC;AAE9B;;;GAGG;;;AAqGH;;;GAGG;AACH;IACE;;OAEG;IACH,eAFa,OAAO,CAAC,OAAO,CAAC,CAI5B;IAED;;;;;OAKG;IACH,yBALW,MAAM,EAAE,4BACR;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,CAAS,IAA6B,EAA7B;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,KAAG,IAAI,CAAA;KAAC,GAC5E,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,KAAK,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAG,MAAM,OAAA,CAAA;SAAC,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,CAsErJ;CACF"}

package/dist/src/services/NodeDragService.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Nodes carried by a drag started on `node`: the whole selection when the
+ * node belongs to it, the node alone otherwise.
+ * @param {Object} node
+ * @param {Array} selectedNodes
+ * @return {Array}
+ */
+export function draggedNodes(node: any, selectedNodes?: any[]): any[];
+/**
+ * Fill a `dragstart` event with the Pristy nodes being dragged.
+ * @param {DragEvent} event
+ * @param {Object} node
+ * @param {Array} selectedNodes
+ */
+export function startNodeDrag(event: DragEvent, node: any, selectedNodes?: any[]): void;
+/**
+ * Forget the nodes of the drag in progress.
+ */
+export function endNodeDrag(): void;
+/**
+ * Whether a node is part of the drag in progress.
+ * @param {string} id
+ * @return {boolean}
+ */
+export function isDragged(id: string): boolean;
+/**
+ * Pass-through attributes making a DataTable row draggable.
+ * @param {Object} node
+ * @return {Object}
+ */
+export function draggableRowAttrs(node: any): any;
+/**
+ * Capture-phase `dragstart` handler for a DataTable root.
+ * @param {DragEvent} event
+ * @param {Array} nodes the rows of the table
+ * @param {Array} selectedNodes
+ */
+export function startRowDrag(event: DragEvent, nodes: any[], selectedNodes?: any[]): void;
+/**
+ * Whether a drag event carries Pristy nodes. Readable during `dragover`,
+ * where the payload itself is not.
+ * @param {DragEvent} event
+ * @return {boolean}
+ */
+export function isNodeDrag(event: DragEvent): boolean;
+/**
+ * Read the Pristy nodes of a `drop` event.
+ * @param {DragEvent} event
+ * @return {Array} empty when the event carries no Pristy nodes
+ */
+export function readNodeDrag(event: DragEvent): any[];
+/**
+ * Attributes making a folder row or card a drop target for Pristy nodes.
+ * @param {Object} folder
+ * @param {Function} onDrop called with (nodes, folder)
+ * @return {Object} empty for a file
+ */
+export function folderDropAttrs(folder: any, onDrop: Function): any;
+/**
+ * Attributes making a PDF row or card a drop target for PDF files only.
+ * @param {Object} file
+ * @param {Function} onDrop called with (nodes, file)
+ * @return {Object} empty for anything but a PDF file
+ */
+export function pdfDropAttrs(file: any, onDrop: Function): any;
+/**
+ * Drop target attributes of a content row or card: a folder takes any node,
+ * a PDF file takes PDF files, anything else takes nothing.
+ * @param {Object} node
+ * @param {Function} onDrop called with (nodes, node)
+ * @return {Object}
+ */
+export function dropTargetAttrs(node: any, onDrop: Function): any;
+export const NODE_DRAG_MIME: "application/x-pristy-nodes";
+export const DROP_TARGET_CLASS: "node-drop-target";
+export const PDF_MIME: "application/pdf";
+export const NODE_ID_ATTRIBUTE: "data-node-id";
+declare namespace _default {
+    export { NODE_DRAG_MIME };
+    export { draggedNodes };
+    export { draggableRowAttrs };
+    export { dropTargetAttrs };
+    export { endNodeDrag };
+    export { folderDropAttrs };
+    export { pdfDropAttrs };
+    export { isDragged };
+    export { startRowDrag };
+    export { startNodeDrag };
+    export { isNodeDrag };
+    export { readNodeDrag };
+}
+export default _default;
+//# sourceMappingURL=NodeDragService.d.ts.map

package/dist/src/services/NodeDragService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeDragService.d.ts","sourceRoot":"","sources":["../../../src/services/NodeDragService.js"],"names":[],"mappings":"AAsCA;;;;;;GAMG;AACH,sEAKC;AAED;;;;;GAKG;AACH,qCAJW,SAAS,0CAcnB;AAED;;GAEG;AACH,oCAEC;AAED;;;;GAIG;AACH,8BAHW,MAAM,GACL,OAAO,CAIlB;AAID;;;;GAIG;AACH,kDAQC;AAED;;;;;GAKG;AACH,oCAJW,SAAS,6CAgBnB;AAED;;;;;GAKG;AACH,kCAHW,SAAS,GACR,OAAO,CAQlB;AAED;;;;GAIG;AACH,oCAHW,SAAS,SAanB;AA8CD;;;;;GAKG;AACH,oEAKC;AAED;;;;;GAKG;AACH,+DASC;AAED;;;;;;GAMG;AACH,kEAIC;AA9ND,6BAA8B,4BAA4B,CAAC;AAE3D,gCAAiC,kBAAkB,CAAC;AAEpD,uBAAwB,iBAAiB,CAAC;AAiE1C,gCAAiC,cAAc,CAAC"}

package/dist/src/services/PdfInsertService.d.ts

@@ -0,0 +1,2 @@
+export function parseNodeId(text: string): string | null;
+//# sourceMappingURL=PdfInsertService.d.ts.map

package/dist/src/services/PdfInsertService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PdfInsertService.d.ts","sourceRoot":"","sources":["../../../src/services/PdfInsertService.js"],"names":[],"mappings":"AAwBO,kCAHI,MAAM,GACJ,MAAM,GAAC,IAAI,CA+BvB"}

package/dist/src/services/PlanSuggestService.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Build the search body listing the nodes that carry a value for `property`.
+ * @param {Object} params
+ * @param {string} params.property - property QName, e.g. "ent:nomTiers"
+ * @param {string} [params.prefix] - what the user typed so far
+ * @param {string} [params.siteId] - workspace short name restricting the search
+ * @returns {Object} body for searchApi.search
+ */
+export function buildSuggestQuery({ property, prefix, siteId }: {
+    property: string;
+    prefix?: string;
+    siteId?: string;
+}): any;
+/**
+ * Distinct values of `property` among the search entries, sorted, those
+ * starting with `prefix` first.
+ * @param {Array} entries - searchApi result entries
+ * @param {string} property
+ * @param {string} [prefix]
+ * @returns {string[]}
+ */
+export function distinctValues(entries: any[], property: string, prefix?: string): string[];
+/**
+ * Values already entered for `property` in the workspace.
+ * @param {Object} params - see buildSuggestQuery
+ * @returns {Promise<string[]>}
+ */
+export function suggestValues(params: any): Promise<string[]>;
+//# sourceMappingURL=PlanSuggestService.d.ts.map

package/dist/src/services/PlanSuggestService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanSuggestService.d.ts","sourceRoot":"","sources":["../../../src/services/PlanSuggestService.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gEALG;IAAuB,QAAQ,EAAvB,MAAM;IACU,MAAM,GAAtB,MAAM;IACU,MAAM,GAAtB,MAAM;CACd,OAqBF;AAED;;;;;;;GAOG;AACH,yDAJW,MAAM,WACN,MAAM,GACJ,MAAM,EAAE,CA0BpB;AAED;;;;GAIG;AACH,4CAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAS7B"}

package/dist/src/services/PlanTreePdfService.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @param {string} text
+ * @param {Object} font
+ * @param {number} size
+ * @param {number} width the room available
+ * @returns {string[]} the text cut at spaces into lines fitting that width; a
+ *   word longer than the width stays whole
+ */
+export function wrapText(text: string, font: any, size: number, width: number): string[];
+/**
+ * @param {Object} options
+ * @param {string} options.title
+ * @param {string} [options.subtitle]
+ * @param {Array<Object>} options.lines as returned by `planTreeLines`
+ * @param {Object} options.texts the translated words: `dynamic`, `missing`,
+ *   `hidden`, `natureCount(count)` and `page(number, total)`
+ * @returns {Promise<Uint8Array>} an A4 PDF listing the plan folder tree,
+ *   folders in bold followed by their nature count, natures with their code
+ */
+export function buildPlanTreePdf({ title, subtitle, lines, texts }: {
+    title: string;
+    subtitle?: string;
+    lines: Array<any>;
+    texts: any;
+}): Promise<Uint8Array>;
+//# sourceMappingURL=PlanTreePdfService.d.ts.map

package/dist/src/services/PlanTreePdfService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlanTreePdfService.d.ts","sourceRoot":"","sources":["../../../src/services/PlanTreePdfService.js"],"names":[],"mappings":"AA+CA;;;;;;;GAOG;AACH,+BAPW,MAAM,mBAEN,MAAM,SACN,MAAM,GACJ,MAAM,EAAE,CAoBpB;AAED;;;;;;;;;GASG;AACH,oEARG;IAAwB,KAAK,EAArB,MAAM;IACW,QAAQ,GAAzB,MAAM;IACiB,KAAK,EAA5B,KAAK,KAAQ;IACG,KAAK;CAE7B,GAAU,OAAO,CAAC,UAAU,CAAC,CA4F/B"}

package/dist/src/services/WorkspaceService.d.ts

@@ -9,18 +9,60 @@ declare class WorkspaceService {
     lruWorkspaces: QuickLRU<any, any>;
     getWorkspaces(): Promise<any>;
     searchAllWorkspaces(extraQuery?: string): Promise<any>;
+    /**
+     * Finds the sites whose short name, title or description contain a term,
+     * searched by the server so that it reaches beyond the listing limit.
+     * @param {string} term at least 2 characters, escaped by the server
+     * @param {number} maxItems maximum number of sites returned
+     * @returns {Promise<{sites: Array, hasMoreItems: boolean}>} sites shaped
+     *   like `getWorkspaces()` entries, role included
+     */
+    findWorkspaces(term: string, maxItems: number): Promise<{
+        sites: any[];
+        hasMoreItems: boolean;
+    }>;
+    /**
+     * Fetches the site nodes of the given guids, shaped like
+     * `searchAllWorkspaces()` entries.
+     * @param {Array<string>} guids site node guids
+     * @returns {Promise<Array>} the site nodes found
+     */
+    searchWorkspaceNodes(guids: Array<string>): Promise<any[]>;
+    _toWorkspaceNode(entry: any): any;
     /**
      * Call sitesApi.getSite to get Site
      * @param id siteid
      * @returns {Promise<Site>}
      */
     getWorkspace(id: any): Promise<Site>;
+    /**
+     * @param {string} id site short name
+     * @returns {Promise<{count: number, members: Array<{id: string, name: string}>}>}
+     *   how many members the site has, and its first three
+     */
+    getWorkspaceMemberSummary(id: string): Promise<{
+        count: number;
+        members: Array<{
+            id: string;
+            name: string;
+        }>;
+    }>;
     getWorkspaceMemberships(id: any): Promise<any>;
     getWorkspaceMembershipsWithOpts(id: any, opts: any): Promise<any>;
     getWorkspaceGroupsWithOpts(id: any, opts: any): Promise<any>;
     getWorkspaceGroups(id: any): Promise<any>;
     createWorkspace(id: any, title: any, descr: any, visibility: any): Promise< SiteEntry>;
+    /**
+     * Invalidate cache entries listing workspaces or describing one of them
+     * @private
+     */
+    private _invalidateWorkspacesCache;
     requestJoinWorkspace(personId: any, siteId: any): Promise< SiteMembershipRequestEntry>;
+    /**
+     * @returns {Promise<Set<string>>} short names of the moderated sites the
+     *   current user asked to join and is still waiting for
+     */
+    getPendingJoinRequests(): Promise<Set<string>>;
     /**
      * Invalidate cache entries for workspace members
      * @private

package/dist/src/services/WorkspaceService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkspaceService.d.ts","sourceRoot":"","sources":["../../../src/services/WorkspaceService.js"],"names":[],"mappings":";;;AAqBA;;GAEG;AACH;IAEI,kCAGE;IAEJ,8BAqBC;IAED,uDAoCC;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED,+CAkBC;IAED,kEAeC;IAED,6DAgBC;IAED,0CAkBC;IAED,iHAWC;IAED,iHAeC;IAED;;;OAGG;IACH,gCAcC;IAED,2GAgBC;IAED,4GAgBC;IAED,qHAeC;IAED,sHAeC;IAED,6DAUC;IAED,+DAUC;IAED,iGAgBC;IAED,6FAUC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,aACN,MAAM,GACJ,OAAO,OAAO,CA+C1B;IAED;;;;;;;;;;;OAWG;IACH,mBAJW,MAAM,aACN,MAAM,GACJ,OAAO,OAAO,CAoD1B;IAED,iEAMC;IAED,mFAIC;CACF;qBA5doB,WAAW"}
+{"version":3,"file":"WorkspaceService.d.ts","sourceRoot":"","sources":["../../../src/services/WorkspaceService.js"],"names":[],"mappings":";;;AAuBA;;GAEG;AACH;IAEI,kCAGE;IAEJ,8BAqBC;IAED,uDAiCC;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,YACN,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,QAAQ;QAAC,YAAY,EAAE,OAAO,CAAA;KAAC,CAAC,CAa1D;IAED;;;;;OAKG;IACH,4BAHW,KAAK,CAAC,MAAM,CAAC,GACX,OAAO,OAAO,CA8B1B;IAED,kCAKC;IAED;;;;OAIG;IACH,uBAFa,OAAO,CAAC,IAAI,CAAC,CAmBzB;IAED;;;;OAIG;IACH,8BAJW,MAAM,GACJ,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,KAAK,CAAC;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC,CA4BhF;IAED,+CAkBC;IAED,kEAeC;IAED,6DAgBC;IAED,0CAkBC;IAED,iHAiBC;IAED;;;OAGG;IACH,mCAYC;IAED,iHAqBC;IAED;;;OAGG;IACH,0BAHa,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAqBhC;IAED;;;OAGG;IACH,gCAeC;IAED,2GAgBC;IAED,4GAgBC;IAED,qHAeC;IAED,sHAeC;IAED,6DAUC;IAED,+DAUC;IAED,iGAgBC;IAED,6FAUC;IAED;;;;;OAKG;IACH,kBAJW,MAAM,aACN,MAAM,GACJ,OAAO,OAAO,CA+C1B;IAED;;;;;;;;;;;OAWG;IACH,mBAJW,MAAM,aACN,MAAM,GACJ,OAAO,OAAO,CAoD1B;IAED,iEAYC;IAED,mFAUC;CACF;qBA7nBoB,WAAW"}

package/dist/src/stores/aiImport.d.ts

@@ -0,0 +1,43 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+export const UPLOAD_SENDING: "sending";
+export const UPLOAD_SENT: "sent";
+export const UPLOAD_FAILED: "failed";
+/**
+ * Files being sent to the AI import folder. The upload goes on in the background,
+ * so the import page lists them before their node exists. See `docs/AiImport.md`.
+ */
+export const useAiImportStore: StoreDefinition<"AiImportStore", {
+    folderId: any;
+    uploads: any[];
+}, {
+    pendingUploads: (state: {
+        folderId: any;
+        uploads: any[];
+    } & PiniaCustomStateProperties<{
+        folderId: any;
+        uploads: any[];
+    }>) => any[];
+}, {
+    resolveFolder(): Promise<any>;
+    /**
+     * Resolves the import folder and the plan, then sends the files one by one
+     * without waiting for them.
+     *
+     * @param {File[]} files
+     * @param {{siteId: string, planName: string}} target
+     * @returns {Promise<string>} the import folder id, once the upload has started
+     */
+    startImport(files: File[], target: {
+        siteId: string;
+        planName: string;
+    }): Promise<string>;
+    sendAll(folderId: any, batch: any, context: any): Promise<void>;
+    /**
+     * Forgets the uploads whose node is now listed.
+     *
+     * @param {Set<string>} listedIds node ids present in the folder listing
+     */
+    forgetListed(listedIds: Set<string>): void;
+    dismiss(key: any): void;
+}>;
+//# sourceMappingURL=aiImport.d.ts.map

package/dist/src/stores/aiImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiImport.d.ts","sourceRoot":"","sources":["../../../src/stores/aiImport.js"],"names":[],"mappings":";AAoBA,6BAA8B,SAAS,CAAC;AACxC,0BAA2B,MAAM,CAAC;AAClC,4BAA6B,QAAQ,CAAC;AAItC;;;GAGG;AACH;;;;;;;;;;;;;IAkBI;;;;;;;OAOG;uBAHQ,IAAI,EAAE,UACN;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,GAChC,OAAO,CAAC,MAAM,CAAC;;IAuC5B;;;;OAIG;4BADQ,GAAG,CAAC,MAAM,CAAC;;GAYvB"}

package/dist/src/stores/indexAwait.d.ts

@@ -0,0 +1,83 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+export const INDEX_AWAIT_PHASE: Readonly<{
+    IDLE: "idle";
+    WAITING: "waiting";
+    SLOW: "slow";
+}>;
+export const useIndexAwaitStore: StoreDefinition<"indexAwait", {
+    phase: "idle";
+    done: number;
+    total: number;
+}, {
+    visible: (state: {
+        phase: "idle";
+        done: number;
+        total: number;
+    } & PiniaCustomStateProperties<{
+        phase: "idle";
+        done: number;
+        total: number;
+    }>) => boolean;
+    isSlow: (state: {
+        phase: "idle";
+        done: number;
+        total: number;
+    } & PiniaCustomStateProperties<{
+        phase: "idle";
+        done: number;
+        total: number;
+    }>) => boolean;
+}, {
+    /**
+     * Waits until nodes just changed are searchable, then reruns the page's
+     * query. See `docs/IndexAwait.md` for the decision table.
+     *
+     * @param {string[]} nodeIds
+     * @param {{listingSource?: string, onRefresh?: Function, onUnavailable?: Function, refreshOnDone?: boolean, timeout?: number, background?: boolean}} [options]
+     * @returns {Promise<{status: string, searchable: string[], errors: Array<Object>, rejected: string[], pending: string[]}>}
+     *   never rejects; `status` is `skipped`, `done`, `timeout`, `unavailable` or `background`
+     */
+    waitFor(nodeIds: string[], { listingSource, onRefresh, onUnavailable, refreshOnDone, timeout, background, }?: {
+        listingSource?: string;
+        onRefresh?: Function;
+        onUnavailable?: Function;
+        refreshOnDone?: boolean;
+        timeout?: number;
+        background?: boolean;
+    }): Promise<{
+        status: string;
+        searchable: string[];
+        errors: Array<any>;
+        rejected: string[];
+        pending: string[];
+    }>;
+    beginWait(ids: any, background: any, resolve: any): {
+        id: any;
+        ids: any;
+        done: number;
+        total: any;
+        background: any;
+        backgroundFromStart: any;
+        resolve: any;
+    };
+    updateWait(waitId: any, done: any): void;
+    settleWait(wait: any, result: any, { onRefresh, onUnavailable, refreshOnDone }: {
+        onRefresh: any;
+        onUnavailable: any;
+        refreshOnDone: any;
+    }): Promise<void>;
+    endWait(waitId: any): void;
+    syncProgress(): void;
+    /**
+     * Hides the slow message and reruns the query of the page that waited.
+     *
+     * @returns {Promise<void>}
+     */
+    reload(): Promise<void>;
+    /**
+     * Closes the overlay: every running wait goes on in the background and
+     * refreshes its page silently when it ends.
+     */
+    dismiss(): void;
+}>;
+//# sourceMappingURL=indexAwait.d.ts.map

package/dist/src/stores/indexAwait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexAwait.d.ts","sourceRoot":"","sources":["../../../src/stores/indexAwait.js"],"names":[],"mappings":";AAwBA;;;;GAIG;AAkCH;;;;;;;;;;;;;;;;;;;;;;;;IAWI;;;;;;;;OAQG;qBAJQ,MAAM,EAAE,qFACR;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,WAAW;QAAC,aAAa,CAAC,WAAW;QAAC,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAC,GACvI,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,KAAK,KAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC;;;;;;;;;;;;;;;;;;IAwI1H;;;;OAIG;cADU,OAAO,CAAC,IAAI,CAAC;IAQ1B;;;OAGG;;GAWJ"}

package/dist/src/stores/navigation.d.ts

@@ -57,7 +57,18 @@ export const useNavigationStore: StoreDefinition<"NavigationStore", {
      * @return Promise
      */
     load(workspaceId: any, folderId: any, force: any): Promise<void> | Promise<Node>;
-    loadWithOpts(workspaceId: any, folderId: any, force: any, opts: any): Promise<void> | Promise<Node>;
+    /**
+     * Load a workspace or personal space folder and its children.
+     * Only the latest call writes the state: a call answered after a newer
+     * one started, or after a newer call found the state already current,
+     * changes nothing and resolves with `undefined`.
+     * @param workspaceId Current Workspace id, or null for the user home
+     * @param folderId Current Folder id (optional)
+     * @param force force load (reload) data
+     * @param opts options for getChildrenWithOpts
+     * @return {Promise<Object|undefined>} the folder node loaded
+     */
+    loadWithOpts(workspaceId: any, folderId: any, force: any, opts: any): Promise<any | undefined>;
     /**
      * Silently refresh children for ghost node polling.
      * Does NOT set loading = true (no skeleton flash).

package/dist/src/stores/navigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/stores/navigation.js"],"names":[],"mappings":";AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;;;;;;;;;;;;;;;;;;;IA2BI;;;;;;OAMG;;;IAkJH;;;;;;OAMG;;IA4BH;;;;;;OAMG;;GA4GJ"}
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../src/stores/navigation.js"],"names":[],"mappings":";AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;;;;;;;;;;;;;;;;;;;IA2BI;;;;;;OAMG;;IAiEH;;;;;;;;;;OAUG;0EADS,OAAO,CAAC,MAAO,SAAS,CAAC;IA2FrC;;;;;;OAMG;;IA4BH;;;;;;OAMG;;GA4GJ"}