@thatopen/services 0.25.0 → 0.26.0

package/dist/core/builtin-recipes/index.d.ts

@@ -0,0 +1,9 @@
+import { EngineServicesClient } from '../client';
+import { Recipe } from '../recipes';
+
+export { fragToRevit, ifcToRevit } from './records-to-revit';
+export { rhinoToRevit } from './rhino-to-revit';
+/** The built-in recipes, in catalog order. */
+export declare const builtinRecipes: Recipe<any>[];
+/** Registers every built-in recipe on the client's registry. */
+export declare function registerBuiltinRecipes(client: EngineServicesClient): void;

package/dist/core/builtin-recipes/records-to-revit.d.ts

@@ -0,0 +1,24 @@
+import { Recipe } from '../recipes';
+
+/** A family type of the target, as the target publishes it. */
+interface RevitType {
+    categoryId: string;
+    family: string;
+    type: string;
+}
+interface Settings {
+    /** The Revit type every proposed column gets. */
+    columnType?: RevitType;
+    /**
+     * Trust the records' own style names instead: `lookRef`
+     * "Family:Type" becomes the proposal's Family and Type verbatim. Revit
+     * matches a type exactly and refuses the whole request when one is missing
+     * — right for a model that came FROM this Revit, wrong for anything else.
+     */
+    trustStyleNames?: boolean;
+    /** Also propose free-standing family instances (furniture, equipment). Needs trustStyleNames. */
+    includeInstances?: boolean;
+}
+export declare const fragToRevit: Recipe<Settings>;
+export declare const ifcToRevit: Recipe<Settings>;
+export {};

package/dist/core/builtin-recipes/rhino-to-revit.d.ts

@@ -0,0 +1,16 @@
+import { Recipe } from '../recipes';
+
+/** A family type of the target, as the target publishes it. */
+interface RevitType {
+    categoryId: string;
+    family: string;
+    type: string;
+}
+interface Settings {
+    /** The Rhino layer that drives placement. */
+    layer: string;
+    /** The Revit type every placed object becomes. */
+    instanceType: RevitType;
+}
+export declare const rhinoToRevit: Recipe<Settings>;
+export {};

package/dist/core/builtin-recipes/shared.d.ts

@@ -0,0 +1,42 @@
+import { RecipeContext } from '../recipes';
+import { FragItem } from '../frag-items';
+
+/** The modeling engine's attribute names (its `element-attributes.ts`). */
+export declare const ELEMENT_FIELD = "Element";
+export declare const CARRIED_FIELD = "Carried";
+/** Revit's internal length unit: where every position has to end up. */
+export declare const FEET_PER_METRE: number;
+/** One semantic record, as saved: `params` carries the kind-specific fields. */
+export interface OurRecord {
+    id: string;
+    kind: string;
+    params: Record<string, unknown>;
+    /** The item it rode in (its guid is the publisher's id, when it has one). */
+    item: FragItem;
+}
+/** Every record of a read .frag: items' `Element` plus their `Carried` lists. */
+export declare function recordsOf(items: FragItem[]): OurRecord[];
+/**
+ * A param the converter double-encodes (`params.run`, `params.member`,
+ * `params.definition`… are JSON IN TEXT inside the record's JSON).
+ */
+export declare function innerJson<T>(record: OurRecord, param: string): T | null;
+/** Level id (`datum:N`) → its name, from the document's datum records. */
+export declare function levelNames(records: OurRecord[]): Map<string, string>;
+/**
+ * Source id → what this recipe already made for it, read back from its own
+ * APPLIED suggestions: the i-th id the target answered with is what the i-th
+ * change made. It keeps nothing of its own, so it behaves the same whoever
+ * runs it and wherever (the pattern the first end-to-end conversion proved).
+ */
+export declare function whatItMadeBefore(context: RecipeContext<never> | RecipeContext<unknown>, author: string): Promise<Map<string, string>>;
+/** The project file the person picked as a recipe's source. */
+export interface PickedFile {
+    fileId: string;
+    name: string;
+}
+/** Downloads and reads the picked .frag, with the errors a person can act on. */
+export declare function readPickedFrag(context: RecipeContext<unknown>, picked: PickedFile | undefined): Promise<{
+    picked: PickedFile;
+    contents: import('../frag-items').FragContents;
+}>;

package/dist/core/frag-items.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Reads what a .frag SAYS — its metadata and its items' guids, categories and
+ * attributes — without loading it as something to look at.
+ *
+ * The fragments model loader is for models somebody will render: it starts
+ * workers, builds tiles and boxes, and streams geometry. A recipe wants none
+ * of that. It wants the data, it wants it synchronously enough to loop over,
+ * and it wants it for files that may have no geometry at all.
+ *
+ * So this walks the flatbuffer directly, using the same schema the writer
+ * uses, which also keeps the two honest about each other. The schema comes
+ * from the OPTIONAL PEER `@thatopen/fragments` (plus `flatbuffers`), loaded
+ * when `readFrag` runs — same arrangement as {@link OperationBuilder}.
+ */
+export interface FragItem {
+    localId: number;
+    /** The publisher's own id for this thing — a Rhino object guid, a Revit UniqueId. */
+    guid: string | null;
+    category: string | null;
+    attrs: Record<string, string>;
+}
+export interface FragContents {
+    /** Whatever the publisher declared: units, axes, application. Parsed, or `{}` if unreadable. */
+    metadata: Record<string, unknown>;
+    /** In file order, which for an operation payload is the order the ids come back in. */
+    items: FragItem[];
+}
+export declare function readFrag(bytes: Uint8Array): Promise<FragContents>;