@_linked/react 0.0.1

package/docs/001-react-extraction.md

@@ -0,0 +1,361 @@
+---
+summary: Extract @_linked/react from the LINCD monolith. Covers linkedComponent, linkedSetComponent, LinkedComponentClass, useStyles, and React-specific tests.
+packages: [react]
+---
+
+# @_linked/react — extraction plan (rewrite)
+
+## Goal
+
+Create a new package at `rebrand/react` named `@_linked/react` that contains the React-specific functionality from legacy `src/`, while keeping behavior as close as possible to 1:1.
+
+Scope for this extraction:
+- `linkedComponent` / `linkedSetComponent` and their types/helpers.
+- `LinkedComponentClass`.
+- React utilities/hooks that belong with component integration.
+- React-focused tests from `src/tests/utils/query-tests.tsx` (at minimum the React integration section), plus additional tests for uncovered React behavior.
+
+Hard constraints:
+- Runtime dependency target: `@_linked/core` only.
+- Tests may use in-memory store package (`@_linked/in-mem-store` requested; current repo package is `@_linked/rdf-mem-store`).
+- No intentional functionality changes without explicit user approval.
+
+## Source Inventory (Legacy to Extract)
+
+Primary source files in root `src/`:
+- `src/utils/LinkedComponent.ts`
+- `src/utils/LinkedComponentClass.tsx`
+- `src/utils/Hooks.ts`
+- `src/package.ts` (exports for linked decorators/helpers)
+- `src/tests/query.test.tsx`
+- `src/tests/utils/query-tests.tsx`
+- `src/tests/components.test.tsx` (mostly commented; keep as historical reference, not a strong validation source)
+
+Potentially relevant legacy type surface:
+- `src/interfaces/Component.ts` (legacy/possibly unused, but exported path compatibility may matter)
+
+## Important Core/Mem-Store Notes (for migration)
+
+From `rebrand/core/README.md` changelog and current code:
+- Core has moved to `NodeReferenceValue` (`{id: string}`) APIs.
+- Core no longer ships RDF model classes (`NamedNode`, `Literal`, `Quad`, etc.).
+- Shape instances no longer implement RDF-backed instance graph methods.
+- Query tracing has changed (proxy-based; no `TraceShape`/`TestNode` in core path).
+- Core package registration (`linkedPackage`) no longer includes React component factories; React must provide these.
+- Core still supports `preloadFor(...)`/`BoundComponent` query linking (via component-like objects exposing `.query`).
+
+From `rebrand/rdf-mem-store/README.md`:
+- RDF models and graph mutation APIs live here (`NamedNode`, `Literal`, etc.).
+- `InMemoryStore` integrates with core via `LinkedStorage.setDefaultStore(...)`.
+- `toNamedNode(...)` bridges `NodeReferenceValue` to RDF model nodes.
+- No explicit changelog section found; treat README API docs as current contract.
+
+## Package Structure Target (match existing rebrand package style)
+
+`rebrand/react` will mirror `rebrand/core` + `rebrand/rdf-mem-store` setup:
+- `package.json` with dual CJS/ESM exports and aligned scripts.
+- `tsconfig.json`, `tsconfig-cjs.json`, `tsconfig-esm.json`, and `tsconfig-test.json`.
+- `jest.config.js`.
+- `scripts/dual-package.js`.
+- `src/**` with React runtime code and `src/tests/**` with TSX tests.
+
+Workspace wiring:
+- Add `react` to `rebrand/package.json` workspaces list.
+
+## Risk Register / Potential Problems
+
+1. Dependency-name mismatch:
+- Requested test dependency is `@_linked/in-mem-store`, but repo currently contains `rebrand/rdf-mem-store` as `@_linked/rdf-mem-store`.
+
+2. Legacy API mismatch:
+- Legacy React code references RDF models and collection classes from monolithic `src/`; core no longer exports them.
+
+3. Hooks compatibility risk:
+- Legacy hooks (`useWatchProperty*`) depend on change-listener APIs from legacy model/shape runtime that are not present in core.
+
+4. Test fixture migration risk:
+- Legacy `query-tests.tsx` builds data through old shape instance mutators; new extraction should seed test data via mem-store APIs compatible with core.
+
+5. Packaging/global registration drift:
+- `linkedPackage('lincd')` naming and module tree expectations may need explicit confirmation for `@_linked/react`.
+
+## Phase Plan
+
+### Phase 1 — Scaffold `@_linked/react` package
+Objective:
+- Create package skeleton and tooling that matches `rebrand/core`/`rebrand/rdf-mem-store`.
+
+Tasks:
+- Create `rebrand/react` directories and config files.
+- Configure package name `@_linked/react`.
+- Add workspace entry in `rebrand/package.json`.
+- Add build/compile/test scripts and dual-package script.
+- Set Jest to React-capable test environment (`jsdom`) with `ts-jest`.
+
+Validation:
+- Package installs and TypeScript config resolves.
+- `npm/yarn test` command can run Jest (even if tests are placeholders at this stage).
+
+Deliverable:
+- Empty-but-buildable React package scaffold.
+
+### Phase 2 — Migrate runtime React APIs (no behavior changes)
+Objective:
+- Port runtime React functionality from legacy source to `rebrand/react/src`.
+
+Tasks:
+- Port `linkedComponent` / `linkedSetComponent` implementation and types.
+- Port `LinkedComponentClass`.
+- Port React hooks/utilities (`Hooks.ts`) with minimal required adaptation.
+- Port/create package exports (`src/package.ts`, `src/index.ts`) for React API surface.
+- Update imports to use `@_linked/core` paths and local react package files.
+
+Guardrail:
+- Only adjust imports/types/compatibility adapters required by extracted architecture.
+- If behavior changes seem unavoidable, stop and ask user before proceeding.
+
+Validation:
+- Type-check passes for migrated files.
+- Basic smoke test(s) compile against the new exports.
+
+Deliverable:
+- First working runtime API for `@_linked/react`.
+
+### Phase 3 — Migrate and stabilize React tests
+Objective:
+- Port React tests from legacy suite and make them pass with core + mem-store integration.
+
+Tasks:
+- Bring over `query.test.tsx`/`utils/query-tests.tsx` React-focused tests (at minimum section "6. React Component Integration").
+- Keep test logic as close as possible to legacy behavior.
+- Build fixture/seeding setup using mem-store APIs (`NamedNode`/`Literal`/`toNamedNode`) and core shapes.
+- Configure Jest path aliases so tests use local `rebrand/core/src`, `rebrand/react/src`, and mem-store package source.
+- Add additional tests where React behavior is not covered (e.g. loading state, named-prop set query mapping, preload integration).
+
+Validation:
+- At least one React integration test passes at each sub-step.
+- Final phase target: React integration suite passes in the new package.
+
+Deliverable:
+- Passing React test suite that preserves legacy behavior expectations.
+
+### Phase 4 — Integration verification and docs
+Objective:
+- Verify package interoperability and document migration outcomes.
+
+Tasks:
+- Run package-level build + tests for `rebrand/react`.
+- Run cross-package check(s) proving `@_linked/react` works with `@_linked/core` and mem-store in tests.
+- Add/update `README.md` in `rebrand/react` with usage, package split notes, and known constraints.
+- Update this plan file with completion state + commit hashes.
+
+Validation:
+- Build passes.
+- React test suite passes.
+- Documented import/migration guidance is present.
+
+Deliverable:
+- Ready-to-review `@_linked/react` extraction with evidence.
+
+## Working Rules (must be followed during execution)
+
+- One commit per phase/sub-phase. Update the plan to mark completion before committing so the work + plan update are in the same commit.
+- If a commit hash needs to be added later, the plan-only tweak can be bundled into the next phase’s commit (no extra immediate commit).
+- After each phase/sub-phase, validate the work. If it’s a test-related step, validation must include at least one passing relevant test.
+- After each run, report:
+  - What was done.
+  - Problems encountered.
+  - Changes not originally in the plan.
+  - Validation details with explicit pass/fail counts and what was tested.
+- After each phase/sub-phase, commit changes and update this plan to indicate progress.
+- If a revert is needed later, either commit a follow-up revert/fix or reset to a previous commit if more applicable.
+- In every status update, always state what the next step entails and include its exact phase/sub-phase title.
+
+## Progress Tracking Template
+
+For each completed phase/sub-phase, append:
+- Status: `completed` / `in progress` / `blocked`
+- Commit: `<hash>`
+- Summary: `<1-3 bullets>`
+- Validation:
+  - Tests passed: `<n>`
+  - Tests failed: `<n>`
+  - Command(s): `<exact command>`
+- Deviations from plan: `<none or list>`
+- Next step: `<exact next phase/sub-phase title>`
+
+## Progress Log
+
+### Phase 1 — Scaffold `@_linked/react` package
+- Status: `completed`
+- Commit: `1242c6f`
+- Summary:
+  - Created `rebrand/react` package scaffold with package metadata, dual-output build scripts, TS/Jest config, and starter source files.
+  - Added `react` to `rebrand/package.json` workspaces.
+  - Added a Jest smoke test to validate TS-Jest + JSDOM wiring.
+- Validation:
+  - Tests passed: `1`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm run compile` (in `rebrand/react`) -> pass
+    - `npm test` (in `rebrand/react`) -> pass
+- Deviations from plan:
+  - Added local TypeScript path mapping to `@_linked/core` in `rebrand/react/tsconfig.json` so compile works before core is built.
+  - Used local npm cache (`npm install --cache ./.npm-cache`) due permission issue in `~/.npm`.
+- Next step: `Phase 2 — Migrate runtime React APIs (no behavior changes)`
+
+### Phase 2 — Migrate runtime React APIs (no behavior changes)
+- Status: `completed`
+- Commit: `ce4af64`
+- Summary:
+  - Added core-compatible React runtime implementation in `rebrand/react/src/utils/LinkedComponent.ts` for `linkedComponent` and `linkedSetComponent`.
+  - Added `rebrand/react/src/utils/LinkedComponentClass.tsx` and slimmed hooks to `useStyles` only (`rebrand/react/src/utils/Hooks.ts`), removing legacy watch APIs per direction.
+  - Updated package surface (`rebrand/react/src/package.ts`, `rebrand/react/src/index.ts`) to expose React APIs under package tree `@_linked/react`.
+- Validation:
+  - Tests passed: `3`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm run compile` (in `rebrand/react`) -> pass
+    - `npm test` (in `rebrand/react`) -> pass
+- Deviations from plan:
+  - Added a focused runtime test file `rebrand/react/src/tests/linked-component-runtime.test.tsx` already in Phase 2 to validate migrated runtime behavior before larger Phase 3 test porting.
+- Next step: `Phase 3 — Migrate and stabilize React tests`
+
+### Phase 3 — Migrate and stabilize React tests
+- Status: `completed`
+- Commit: `c27016e`
+- Summary:
+  - Ported the legacy React integration tests (section `6. React Component Integration`) into `rebrand/react/src/tests/query-react-integration.test.tsx` with structure and assertions kept close to the original.
+  - Wired tests to `@_linked/rdf-mem-store` by seeding graph data using `NamedNode`/`Literal` and resolving queries through an `InMemoryStore`-backed query parser.
+  - Updated React runtime types to support typed `preloadFor(...)` and object-query `linkedSetComponent({persons: query}, ...)` test cases.
+- Validation:
+  - Tests passed: `12`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm run compile` (in `rebrand/react`) -> pass
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass
+- Deviations from plan:
+  - Kept the Phase 2 runtime smoke/integration tests alongside the ported legacy integration file to preserve incremental validation.
+- Next step: `Phase 4 — Integration verification and docs`
+
+### Phase 4 — Integration verification and docs
+- Status: `completed`
+- Commit: `85864f5`
+- Summary:
+  - Added `rebrand/react/README.md` documenting package usage, dependencies, and both supported linked set component formats.
+  - Verified package-level build + test for `@_linked/react`.
+  - Re-ran core tests and confirmed no duplicate package-registration warning remains after moving core to a shared package singleton.
+- Validation:
+  - Tests passed: `129`
+  - Tests failed: `0`
+  - Suites passed: `7`
+  - Suites skipped: `1`
+  - Command(s):
+    - `npx jest --config jest.config.js --runInBand` (in `rebrand/core`) -> pass (`4 passed`, `1 skipped`, `98 passed tests`)
+    - `npx tsc -p tsconfig-cjs.json && npx tsc -p tsconfig-esm.json` (in `rebrand/core`) -> pass
+    - `npm run build` (in `rebrand/react`) -> pass
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`3 passed suites`, `12 passed tests`)
+- Deviations from plan:
+  - Included additional core verification in this phase to ensure the package-registration warning was resolved end-to-end.
+- Next step: `Done`
+
+### Phase 4a — README clarification follow-up
+- Status: `completed`
+- Commit: `8c9ed38`
+- Summary:
+  - Expanded `rebrand/react/README.md` introduction to explain query DSL to React-props mapping and linked to the core DSL section.
+  - Documented `@_linked/rdf-mem-store` as the simple starter store and showed `LinkedStorage.setDefaultStore(...)` setup.
+  - Removed watch-hook mention from README notes.
+- Validation:
+  - Tests passed: `12`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`3 passed suites`, `12 passed tests`)
+- Deviations from plan:
+  - Added a post-phase README sub-phase for clarity updates requested after Phase 4 completion.
+- Next step: `Done`
+
+### Phase 4b — Runtime behavior docs follow-up
+- Status: `completed`
+- Commit: `6db3a5e`
+- Summary:
+  - Documented loading/render lifecycle for both `linkedComponent(...)` and `linkedSetComponent(...)`, including first render loading state and rerender after query resolution.
+  - Documented fixed loading fallback element (`<div class="ld-loader" role="status" aria-label="Loading" />`) and clarified that replacement is not currently configurable by API.
+  - Added docs for `_refresh(updatedProps?)`, `of` vs internal `source/sources` mapping, and a full pagination example with `nextPage`, `previousPage`, `setPage`, and `setLimit`.
+- Validation:
+  - Tests passed: `12`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`3 passed suites`, `12 passed tests`)
+- Deviations from plan:
+  - Added additional runtime-behavior clarification section requested after initial docs completion.
+- Next step: `Done`
+
+### Phase 4c — linkedComponent docs structure follow-up
+- Status: `completed`
+- Commit: `fe0bdf2`
+- Summary:
+  - Renamed the section title from "Input props and mapped props" to `linkedComponent(...)`.
+  - Rewrote the intro paragraph to clarify `Shape.query(...)` vs `Shape.select(...)`, subject binding through `of`, and top-level query key-to-prop mapping.
+  - Added an explicit prop breakdown list after the `linkedComponent(...)` example and moved the `@_linked/rdf-mem-store` setup example to the bottom of the README.
+- Validation:
+  - Tests passed: `12`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`3 passed suites`, `12 passed tests`)
+- Deviations from plan:
+  - None.
+- Next step: `Done`
+
+### Phase 4d — `_refresh` semantics and ordering docs follow-up
+- Status: `completed`
+- Commit: `eac17b9`
+- Summary:
+  - Clarified `_refresh(updatedProps)` semantics as patching query-result keys only, not regular/custom props.
+  - Moved the `_refresh` section to the bottom of the `linkedComponent(...)` section before `linkedSetComponent(...)` docs.
+  - Added explicit linked-set purpose text ("render a list of sources") and appended a README TODO list for `setOffset` and configurable loader/loading state.
+- Validation:
+  - Tests passed: `12`
+  - Tests failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`3 passed suites`, `12 passed tests`)
+- Deviations from plan:
+  - None.
+- Next step: `Done`
+
+### Phase 5 — Gap-closure test phase
+- Status: `completed`
+- Commit: `1960921`
+- Summary:
+  - Added `rebrand/react/src/tests/gap-closure-react-behavior.test.tsx` covering loading state rendering, `_refresh()` refetch flow, `_refresh(updatedProps)` local patch flow, linked-set pagination controller methods, set-input validation, query-wrapper validation, source conversion edge cases, and component metadata exposure.
+  - Added `rebrand/react/src/tests/gap-closure-hooks-and-class.test.tsx` covering `useStyles` merge behavior and `LinkedComponentClass` source-shape lifecycle behavior.
+  - Exercised parser-missing error path via `_refresh()` and validated emitted runtime error capture in test harness.
+- Validation:
+  - Tests passed: `30`
+  - Tests failed: `0`
+  - Suites passed: `5`
+  - Suites failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`5 passed suites`, `30 passed tests`)
+- Deviations from plan:
+  - For `linkedSetComponent(null, ...)`, runtime currently throws `TypeError: Cannot convert undefined or null to object` before hitting the friendly `'Unknown data query type'` branch; tests assert the friendly branch via a numeric invalid input.
+  - Parser-missing validation in React event flow required window error capture in tests because the error is reported as an uncaught event error in JSDOM.
+- Next step: `Done`
+
+### Phase 5a — Test-suite reorganization
+- Status: `completed`
+- Commit: `<to be filled after commit>`
+- Summary:
+  - Reorganized React package tests into two files: `react-component-integration.test.tsx` and `react-component-behavior.test.tsx`.
+  - Merged utility coverage (`useStyles`, `LinkedComponentClass`) into the behavior suite and removed `react-component-utils.test.tsx`.
+  - Removed legacy naming (`gap closure`) from describe blocks and dropped redundant smoke/runtime test files from the package test tree.
+- Validation:
+  - Tests passed: `27`
+  - Tests failed: `0`
+  - Suites passed: `2`
+  - Suites failed: `0`
+  - Command(s):
+    - `npm test -- --runInBand` (in `rebrand/react`) -> pass (`2 passed suites`, `27 passed tests`)
+- Deviations from plan:
+  - Test count reduced from prior `30` to `27` after consolidating/removing redundant smoke/runtime coverage; behavior coverage remains represented in the remaining suites.
+- Next step: `Done`

package/jest.config.js

@@ -0,0 +1,20 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'jsdom',
+  rootDir: 'src/tests',
+  testMatch: ['**/*.test.ts', '**/*.test.tsx'],
+  transform: {
+    '^.+\\.(ts|tsx)$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/../../tsconfig-test.json',
+      },
+    ],
+  },
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+    '^@_linked/react/(.*)$': '<rootDir>/../$1',
+    '^@_linked/react$': '<rootDir>/../index',
+  },
+};

package/lib/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './package.js';
+export * from './utils/LinkedComponent.js';
+export * from './utils/LinkedComponentClass.js';
+export * from './utils/Hooks.js';

package/lib/cjs/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./package.js"), exports);
+__exportStar(require("./utils/LinkedComponent.js"), exports);
+__exportStar(require("./utils/LinkedComponentClass.js"), exports);
+__exportStar(require("./utils/Hooks.js"), exports);
+//# sourceMappingURL=index.js.map

package/lib/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,+CAA6B;AAC7B,6DAA2C;AAC3C,kEAAgD;AAChD,mDAAiC"}

package/lib/cjs/package.d.ts

@@ -0,0 +1,10 @@
+import { Shape } from '@_linked/core/shapes/Shape';
+declare const linkedUtil: (constructor: any) => any, linkedOntology: (allFileExports: any, nameSpace: (term: string) => import("@_linked/core/utils/NodeReference.js").NodeReferenceValue, suggestedPrefixAndFileName: string, loadDataFunction?: () => Promise<any>, dataSource?: string | string[]) => void, linkedShape: {
+    <T extends typeof Shape>(constructor: T): void;
+    <T extends typeof Shape>(config?: import("@_linked/core/utils/Package").ShapeConfig): (constructor: T) => void;
+}, registerPackageExport: (exportedObject: any) => void, registerPackageModule: (_module: any) => void, packageExports: any, getPackageShape: (name: string) => typeof Shape;
+declare const linkedComponent: <QueryType extends import("@_linked/core/queries/SelectQuery.js").SelectQueryFactory<any> = null, CustomProps = {}, ShapeType extends Shape = import("@_linked/core/queries/SelectQuery.js").GetQueryShapeType<QueryType>, Res = import("@_linked/core/queries/SelectQuery.js").GetQueryResponseType<QueryType>>(query: QueryType, functionalComponent: import("./utils/LinkedComponent.js").LinkableComponent<CustomProps & import("@_linked/core/queries/SelectQuery.js").QueryResponseToResultType<Res, ShapeType>, ShapeType>) => import("./utils/LinkedComponent.js").LinkedComponent<CustomProps, ShapeType, Res>;
+declare const linkedSetComponent: <QueryType extends import("@_linked/core/queries/SelectQuery.js").SelectQueryFactory<any> | {
+    [key: string]: import("@_linked/core/queries/SelectQuery.js").SelectQueryFactory<any>;
+} = null, CustomProps = {}, ShapeType extends Shape = import("@_linked/core/queries/SelectQuery.js").GetQueryShapeType<QueryType>, Res = import("@_linked/core/queries/SelectQuery.js").ToQueryResultSet<QueryType>>(query: QueryType, functionalComponent: import("./utils/LinkedComponent.js").LinkableSetComponent<CustomProps & import("@_linked/core/queries/SelectQuery.js").GetCustomObjectKeys<QueryType> & import("@_linked/core/queries/SelectQuery.js").QueryControllerProps, ShapeType>) => import("./utils/LinkedComponent.js").LinkedSetComponent<CustomProps, ShapeType, Res>;
+export { linkedComponent, linkedSetComponent, linkedShape, linkedUtil, linkedOntology, registerPackageExport, registerPackageModule, packageExports, getPackageShape, };

package/lib/cjs/package.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageShape = exports.packageExports = exports.registerPackageModule = exports.registerPackageExport = exports.linkedOntology = exports.linkedUtil = exports.linkedShape = exports.linkedSetComponent = exports.linkedComponent = void 0;
+const CoreSet_1 = require("@_linked/core/collections/CoreSet");
+const Package_1 = require("@_linked/core/utils/Package");
+const LinkedComponent_js_1 = require("./utils/LinkedComponent.js");
+let shapeToComponents = new Map();
+const { linkedUtil, linkedOntology, linkedShape, registerPackageExport, registerPackageModule, packageExports, getPackageShape, } = (0, Package_1.linkedPackage)('@_linked/react');
+exports.linkedUtil = linkedUtil;
+exports.linkedOntology = linkedOntology;
+exports.linkedShape = linkedShape;
+exports.registerPackageExport = registerPackageExport;
+exports.registerPackageModule = registerPackageModule;
+exports.packageExports = packageExports;
+exports.getPackageShape = getPackageShape;
+function registerComponent(exportedComponent, shape) {
+    if (!shape) {
+        if (!Object.prototype.hasOwnProperty.call(exportedComponent, 'shape')) {
+            console.warn(`Component ${exportedComponent.displayName || exportedComponent.name} is not linked to a shape.`);
+            return;
+        }
+        shape = exportedComponent.shape;
+    }
+    if (!shapeToComponents.has(shape)) {
+        shapeToComponents.set(shape, new CoreSet_1.CoreSet());
+    }
+    shapeToComponents.get(shape).add(exportedComponent);
+}
+const linkedComponent = (0, LinkedComponent_js_1.createLinkedComponentFn)(registerPackageExport, registerComponent);
+exports.linkedComponent = linkedComponent;
+const linkedSetComponent = (0, LinkedComponent_js_1.createLinkedSetComponentFn)(registerPackageExport, registerComponent);
+exports.linkedSetComponent = linkedSetComponent;
+//# sourceMappingURL=package.js.map

package/lib/cjs/package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.js","sourceRoot":"","sources":["../../src/package.ts"],"names":[],"mappings":";;;AAAA,+DAA0D;AAC1D,yDAA0D;AAE1D,mEAIoC;AAEpC,IAAI,iBAAiB,GAA0C,IAAI,GAAG,EAAE,CAAC;AAEzE,MAAM,EACJ,UAAU,EACV,cAAc,EACd,WAAW,EACX,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACd,eAAe,GAChB,GAAG,IAAA,uBAAa,EAAC,gBAAgB,CAAC,CAAC;AAoClC,gCAAU;AACV,wCAAc;AAFd,kCAAW;AAGX,sDAAqB;AACrB,sDAAqB;AACrB,wCAAc;AACd,0CAAe;AAvCjB,SAAS,iBAAiB,CAAC,iBAA4B,EAAE,KAAoB;IAC3E,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAC,EAAE,CAAC;YACtE,OAAO,CAAC,IAAI,CACV,aACE,iBAAiB,CAAC,WAAW,IAAI,iBAAiB,CAAC,IACrD,4BAA4B,CAC7B,CAAC;YACF,OAAO;QACT,CAAC;QACD,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC;IAClC,CAAC;IAED,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,iBAAiB,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,iBAAO,EAAO,CAAC,CAAC;IACnD,CAAC;IAED,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;AACtD,CAAC;AAED,MAAM,eAAe,GAAG,IAAA,4CAAuB,EAC7C,qBAAqB,EACrB,iBAAiB,CAClB,CAAC;AAQA,0CAAe;AANjB,MAAM,kBAAkB,GAAG,IAAA,+CAA0B,EACnD,qBAAqB,EACrB,iBAAiB,CAClB,CAAC;AAIA,gDAAkB"}

package/lib/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/cjs/utils/Hooks.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+/**
+ * Merge className/style props with local style inputs.
+ */
+export declare const useStyles: (props: any, classNamesOrStyles?: string | string[] | React.CSSProperties, styles?: React.CSSProperties) => any;

package/lib/cjs/utils/Hooks.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStyles = void 0;
+/**
+ * Merge className/style props with local style inputs.
+ */
+const useStyles = (props, classNamesOrStyles, styles) => {
+    let classNames;
+    let combinedStyles;
+    let propsCopy = Object.assign({}, props);
+    if (props.className) {
+        if (typeof props.className === 'string') {
+            classNames = [props.className];
+        }
+        else if (Array.isArray(props.className)) {
+            classNames = props.className;
+        }
+        delete propsCopy.className;
+    }
+    if (props.style) {
+        combinedStyles = props.style;
+        delete propsCopy.style;
+    }
+    if (classNamesOrStyles) {
+        let paramType = typeof classNamesOrStyles;
+        if (paramType === 'string') {
+            if (classNames) {
+                classNames.push(classNamesOrStyles);
+            }
+            else {
+                classNames = [classNamesOrStyles];
+            }
+        }
+        else if (paramType === 'object') {
+            if (Array.isArray(classNamesOrStyles)) {
+                if (classNames) {
+                    classNames = classNames.concat(classNamesOrStyles);
+                }
+                else {
+                    classNames = classNamesOrStyles;
+                }
+            }
+            else {
+                combinedStyles = Object.assign(Object.assign({}, props.style), classNamesOrStyles);
+            }
+        }
+        if (styles) {
+            combinedStyles = Object.assign(Object.assign({}, combinedStyles), styles);
+        }
+    }
+    return Object.assign({ className: (classNames || []).filter(Boolean).join(' '), style: combinedStyles }, propsCopy);
+};
+exports.useStyles = useStyles;
+//# sourceMappingURL=Hooks.js.map

package/lib/cjs/utils/Hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hooks.js","sourceRoot":"","sources":["../../../src/utils/Hooks.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACI,MAAM,SAAS,GAAG,CACvB,KAAK,EACL,kBAA4D,EAC5D,MAA4B,EAC5B,EAAE;IACF,IAAI,UAAU,CAAC;IACf,IAAI,cAAc,CAAC;IACnB,IAAI,SAAS,qBAAO,KAAK,CAAC,CAAC;IAC3B,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpB,IAAI,OAAO,KAAK,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACxC,UAAU,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACjC,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1C,UAAU,GAAG,KAAK,CAAC,SAAS,CAAC;QAC/B,CAAC;QACD,OAAO,SAAS,CAAC,SAAS,CAAC;IAC7B,CAAC;IACD,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,cAAc,GAAG,KAAK,CAAC,KAAK,CAAC;QAC7B,OAAO,SAAS,CAAC,KAAK,CAAC;IACzB,CAAC;IAED,IAAI,kBAAkB,EAAE,CAAC;QACvB,IAAI,SAAS,GAAG,OAAO,kBAAkB,CAAC;QAC1C,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC3B,IAAI,UAAU,EAAE,CAAC;gBACf,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACtC,CAAC;iBAAM,CAAC;gBACN,UAAU,GAAG,CAAC,kBAAkB,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;aAAM,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;gBACtC,IAAI,UAAU,EAAE,CAAC;oBACf,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC;gBACrD,CAAC;qBAAM,CAAC;oBACN,UAAU,GAAG,kBAAkB,CAAC;gBAClC,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,cAAc,mCAAO,KAAK,CAAC,KAAK,GAAM,kBAA6B,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;QACD,IAAI,MAAM,EAAE,CAAC;YACX,cAAc,mCAAO,cAAc,GAAK,MAAM,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED,uBACE,SAAS,EAAE,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EACvD,KAAK,EAAE,cAAc,IAClB,SAAS,EACZ;AACJ,CAAC,CAAC;AAlDW,QAAA,SAAS,aAkDpB"}

package/lib/cjs/utils/LinkedComponent.d.ts

@@ -0,0 +1,52 @@
+import { GetCustomObjectKeys, GetQueryResponseType, GetQueryShapeType, QResult, QueryControllerProps, QueryResponseToResultType, QueryWrapperObject, SelectQueryFactory, ToQueryResultSet } from '@_linked/core/queries/SelectQuery';
+import { Shape } from '@_linked/core/shapes/Shape';
+import React from 'react';
+import { ShapeSet } from '@_linked/core/collections/ShapeSet';
+import { NodeReferenceValue } from '@_linked/core/utils/NodeReference';
+export type Component<P = any, ShapeType extends Shape = Shape> = ClassComponent<P, ShapeType> | LinkedComponent<P, ShapeType> | LinkedSetComponent<P, ShapeType>;
+export interface ClassComponent<P, ShapeType extends Shape = Shape> extends React.ComponentClass<P & LinkedComponentProps<ShapeType>> {
+    props: P & LinkedComponentProps<ShapeType>;
+    shape?: typeof Shape;
+}
+export interface LinkedComponent<P, ShapeType extends Shape = Shape, ResultType = any> extends React.FC<P & LinkedComponentInputProps<ShapeType> & React.ComponentPropsWithRef<any>> {
+    original?: LinkableComponent<P, ShapeType>;
+    query: SelectQueryFactory<any>;
+    shape?: typeof Shape;
+}
+export interface LinkedSetComponent<P, ShapeType extends Shape = Shape, Res = any> extends React.FC<P & LinkedSetComponentInputProps<ShapeType> & React.ComponentPropsWithRef<any>> {
+    original?: LinkableSetComponent<P, ShapeType>;
+    query: SelectQueryFactory<any> | QueryWrapperObject<ShapeType>;
+    shape?: typeof Shape;
+}
+export type LinkableComponent<P, ShapeType extends Shape = Shape> = React.FC<P & LinkedComponentProps<ShapeType>>;
+export type LinkableSetComponent<P, ShapeType extends Shape = Shape, DataResultType = any> = React.FC<LinkedSetComponentProps<ShapeType, DataResultType> & P>;
+export interface LinkedSetComponentProps<ShapeType extends Shape, DataResultType = any> extends LinkedComponentBaseProps<DataResultType>, QueryControllerProps {
+    sources: ShapeSet<ShapeType>;
+}
+export interface LinkedComponentProps<ShapeType extends Shape> extends LinkedComponentBaseProps {
+    source: ShapeType;
+    _refresh: (updatedProps?: any) => void;
+}
+interface LinkedComponentBaseProps<DataResultType = any> extends React.PropsWithChildren {
+    linkedData?: DataResultType;
+}
+export interface LinkedSetComponentInputProps<ShapeType extends Shape = Shape> extends LinkedComponentInputBaseProps {
+    of?: ShapeSet<ShapeType> | QResult<ShapeType>[];
+}
+export interface LinkedComponentInputProps<ShapeType extends Shape = Shape> extends LinkedComponentInputBaseProps {
+    of: NodeReferenceValue | ShapeType | QResult<ShapeType>;
+}
+interface LinkedComponentInputBaseProps extends React.PropsWithChildren {
+    className?: string | string[];
+    style?: React.CSSProperties;
+}
+export type LinkedSetComponentFactoryFn = <QueryType extends SelectQueryFactory<any> | {
+    [key: string]: SelectQueryFactory<any>;
+} = null, CustomProps = {}, ShapeType extends Shape = GetQueryShapeType<QueryType>, Res = ToQueryResultSet<QueryType>>(requiredData: QueryType, functionalComponent: LinkableSetComponent<CustomProps & GetCustomObjectKeys<QueryType> & QueryControllerProps, ShapeType, Res>) => LinkedSetComponent<CustomProps, ShapeType, Res>;
+export type LinkedComponentFactoryFn = <QueryType extends SelectQueryFactory<any> = null, CustomProps = {}, ShapeType extends Shape = GetQueryShapeType<QueryType>, Response = GetQueryResponseType<QueryType>, ResultType = QueryResponseToResultType<Response, ShapeType>>(query: QueryType, functionalComponent: LinkableComponent<CustomProps & ResultType, ShapeType>) => LinkedComponent<CustomProps, ShapeType, ResultType>;
+export declare function createLinkedComponentFn(registerPackageExport: any, registerComponent: any): <QueryType extends SelectQueryFactory<any> = null, CustomProps = {}, ShapeType extends Shape = GetQueryShapeType<QueryType>, Res = GetQueryResponseType<QueryType>>(query: QueryType, functionalComponent: LinkableComponent<CustomProps & QueryResponseToResultType<Res, ShapeType>, ShapeType>) => LinkedComponent<CustomProps, ShapeType, Res>;
+export declare function createLinkedSetComponentFn(registerPackageExport: any, registerComponent: any): <QueryType extends SelectQueryFactory<any> | {
+    [key: string]: SelectQueryFactory<any>;
+} = null, CustomProps = {}, ShapeType extends Shape = GetQueryShapeType<QueryType>, Res = ToQueryResultSet<QueryType>>(query: QueryType, functionalComponent: LinkableSetComponent<CustomProps & GetCustomObjectKeys<QueryType> & QueryControllerProps, ShapeType>) => LinkedSetComponent<CustomProps, ShapeType, Res>;
+export declare function getSourceFromInputProps(props: any, shapeClass: any): any;
+export {};