Add comprehensive library expansion with new components and demos

- Add new libraries: ui-accessibility, ui-animations, ui-backgrounds, ui-code-display, ui-data-utils, ui-font-manager, hcl-studio
- Add extensive layout components: gallery-grid, infinite-scroll-container, kanban-board, masonry, split-view, sticky-layout
- Add comprehensive demo components for all new features
- Update project configuration and dependencies
- Expand component exports and routing structure
- Add UI landing pages planning document

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

projects/ui-code-display/node_modules/rxjs/src/internal/observable/bindCallbackInternals.ts

@@ -0,0 +1,119 @@
+import { SchedulerLike } from '../types';
+import { isScheduler } from '../util/isScheduler';
+import { Observable } from '../Observable';
+import { subscribeOn } from '../operators/subscribeOn';
+import { mapOneOrManyArgs } from '../util/mapOneOrManyArgs';
+import { observeOn } from '../operators/observeOn';
+import { AsyncSubject } from '../AsyncSubject';
+
+export function bindCallbackInternals(
+  isNodeStyle: boolean,
+  callbackFunc: any,
+  resultSelector?: any,
+  scheduler?: SchedulerLike
+): (...args: any[]) => Observable<unknown> {
+  if (resultSelector) {
+    if (isScheduler(resultSelector)) {
+      scheduler = resultSelector;
+    } else {
+      // The user provided a result selector.
+      return function (this: any, ...args: any[]) {
+        return (bindCallbackInternals(isNodeStyle, callbackFunc, scheduler) as any)
+          .apply(this, args)
+          .pipe(mapOneOrManyArgs(resultSelector as any));
+      };
+    }
+  }
+
+  // If a scheduler was passed, use our `subscribeOn` and `observeOn` operators
+  // to compose that behavior for the user.
+  if (scheduler) {
+    return function (this: any, ...args: any[]) {
+      return (bindCallbackInternals(isNodeStyle, callbackFunc) as any)
+        .apply(this, args)
+        .pipe(subscribeOn(scheduler!), observeOn(scheduler!));
+    };
+  }
+
+  return function (this: any, ...args: any[]): Observable<any> {
+    // We're using AsyncSubject, because it emits when it completes,
+    // and it will play the value to all late-arriving subscribers.
+    const subject = new AsyncSubject<any>();
+
+    // If this is true, then we haven't called our function yet.
+    let uninitialized = true;
+    return new Observable((subscriber) => {
+      // Add our subscriber to the subject.
+      const subs = subject.subscribe(subscriber);
+
+      if (uninitialized) {
+        uninitialized = false;
+        // We're going to execute the bound function
+        // This bit is to signal that we are hitting the callback asynchronously.
+        // Because we don't have any anti-"Zalgo" guarantees with whatever
+        // function we are handed, we use this bit to figure out whether or not
+        // we are getting hit in a callback synchronously during our call.
+        let isAsync = false;
+
+        // This is used to signal that the callback completed synchronously.
+        let isComplete = false;
+
+        // Call our function that has a callback. If at any time during this
+        // call, an error is thrown, it will be caught by the Observable
+        // subscription process and sent to the consumer.
+        callbackFunc.apply(
+          // Pass the appropriate `this` context.
+          this,
+          [
+            // Pass the arguments.
+            ...args,
+            // And our callback handler.
+            (...results: any[]) => {
+              if (isNodeStyle) {
+                // If this is a node callback, shift the first value off of the
+                // results and check it, as it is the error argument. By shifting,
+                // we leave only the argument(s) we want to pass to the consumer.
+                const err = results.shift();
+                if (err != null) {
+                  subject.error(err);
+                  // If we've errored, we can stop processing this function
+                  // as there's nothing else to do. Just return to escape.
+                  return;
+                }
+              }
+              // If we have one argument, notify the consumer
+              // of it as a single value, otherwise, if there's more than one, pass
+              // them as an array. Note that if there are no arguments, `undefined`
+              // will be emitted.
+              subject.next(1 < results.length ? results : results[0]);
+              // Flip this flag, so we know we can complete it in the synchronous
+              // case below.
+              isComplete = true;
+              // If we're not asynchronous, we need to defer the `complete` call
+              // until after the call to the function is over. This is because an
+              // error could be thrown in the function after it calls our callback,
+              // and if that is the case, if we complete here, we are unable to notify
+              // the consumer than an error occurred.
+              if (isAsync) {
+                subject.complete();
+              }
+            },
+          ]
+        );
+        // If we flipped `isComplete` during the call, we resolved synchronously,
+        // notify complete, because we skipped it in the callback to wait
+        // to make sure there were no errors during the call.
+        if (isComplete) {
+          subject.complete();
+        }
+
+        // We're no longer synchronous. If the callback is called at this point
+        // we can notify complete on the spot.
+        isAsync = true;
+      }
+
+      // Return the subscription from adding our subscriber to the subject.
+      return subs;
+    });
+  };
+}