fix: translate linked-signal and resource guide (#1001)

Author: lacolaco

Diff for: adev-ja/src/content/guide/signals/linked-signal.en.md

@@ -0,0 +1,109 @@
+# `linkedSignal`
+
+IMPORTANT: `linkedSignal` is [developer preview](reference/releases#developer-preview). It's ready for you to try, but it might change before it is stable.
+
+You can use the `signal` function to hold some state in your Angular code. Sometimes, this state depends on some _other_ state. For example, imagine a component that lets the user select a shipping method for an order:
+
+```typescript
+@Component({/* ... */})
+export class ShippingMethodPicker {
+  shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
+
+  // Select the first shipping option by default.
+  selectedOption = signal(this.shippingOptions()[0]);
+
+  changeShipping(newOptionIndex: number) {
+    this.selectedOption.set(this.shippingOptions()[newOptionIndex]);
+  }
+}
+``` 
+
+In this example, the `selectedOption` defaults to the first option, but changes if the user selects another option. But `shippingOptions` is a signal— its value may change! If `shippingOptions` changes, `selectedOption` may contain a value that is no longer a valid option.
+
+**The `linkedSignal` function lets you create a signal to hold some state that is intrinsically _linked_ to some other state.** Revisiting the example above, `linkedSignal` can replace `signal`:
+
+```typescript
+@Component({/* ... */})
+export class ShippingMethodPicker {
+  shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
+
+  // Initialize selectedOption to the first shipping option.
+  selectedOption = linkedSignal(() => this.shippingOptions()[0]);
+
+  changeShipping(index: number) {
+    this.selectedOption.set(this.shippingOptions()[index]);
+  }
+}
+```
+
+`linkedSignal` works similarly to `signal` with one key difference— instead of passing a default value, you pass a _computation function_, just like `computed`. When the value of the computation changes, the value of the `linkedSignal` changes to the computation result. This helps ensure that the `linkedSignal` always has a valid value.
+
+The following example shows how the value of a `linkedSignal` can change based on its linked state:
+
+```typescript
+const shippingOptions = signal(['Ground', 'Air', 'Sea']);
+const selectedOption = linkedSignal(() => shippingOptions()[0]);
+console.log(selectedOption()); // 'Ground'
+
+selectedOption.set(shippingOptions[2]);
+console.log(selectedOption()); // 'Sea'
+
+shippingOptions.set(['Email', 'Will Call', 'Postal service']);
+console.log(selectedOption()); // 'Email'
+```
+
+## Accounting for previous state
+
+In some cases, the computation for a `linkedSignal` needs to account for the previous value of the `linkedSignal`.
+
+In the example above, `selectedOption` always updates back to the first option when `shippingOptions` changes. You may, however, want to preserve the user's selection if their selected option is still somewhere in the list. To accomplish this, you can create a `linkedSignal` with a separate _source_ and _computation_:
+
+```typescript
+@Component({/* ... */})
+export class ShippingMethodPicker {
+  shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
+  
+  selectedOption = linkedSignal({
+    // `selectedOption` is set to the `computation` result whenever this `source` changes.
+    source: shippingOptions,
+    computation: (newOptions, previous) => {
+      // If the newOptions contain the previously selected option, preserve that selection.
+      // Otherwise, default to the first option.
+      return newOptions.find(opt => opt.id === previous?.value) ?? newOptions[0];
+    } 
+  });
+
+  changeShipping(newOptionIndex: number) {
+    this.selectedOption.set(this.shippingOptions()[newOptionIndex]);
+  }
+}
+```
+
+When you create a `linkedSignal`, you can pass an object with separate `source` and `computation` properties instead of providing just a computation.
+
+The `source` can be any signal, such as a `computed` or component `input`. When the value of `source` changes, `linkedSignal` updates its value to the result of the provided `computation`.
+
+The `computation` is a function that receives the new value of `source` and a `previous` object. The `previous` object has two properties— `previous.source` is the previous value of `source`, and `previous.value` is the previous result of the `computation`. You can use these previous values to decide the new result of the computation.
+
+## Custom equality comparison
+
+`linkedSignal` updates to the result of the computation every time its linked state changes. By default, Angular uses referential equality to determine if the linked state has changed. You can alternatively provide a custom equality function.
+
+```typescript
+const activeUser = signal({id: 123, name: 'Morgan'});
+const email = linkedSignal(() => `${activeUser().name}@example.com`, {
+  // Consider the user as the same if it's the same `id`.
+  equal: (a, b) => a.id === b.id,
+});
+
+// Or, if separating `source` and `computation`
+const alternateEmail = linkedSignal({
+  source: activeUser,
+  computation: user => `${user.name}@example.com`,
+  equal: (a, b) => a.id === b.id,
+});
+
+// This update to `activeUser` does not cause `email` or `alternateEmail`
+// to update because the `id` is the same.
+activeUser.set({id: 123, name: 'Morgan', isAdmin: false});
+```

Diff for: adev-ja/src/content/guide/signals/linked-signal.md

@@ -1,33 +1,33 @@
 # `linkedSignal`
 
-IMPORTANT: `linkedSignal` is [developer preview](reference/releases#developer-preview). It's ready for you to try, but it might change before it is stable.
+IMPORTANT: `linkedSignal`は[開発者プレビュー](reference/releases#developer-preview)です。試用できますが、安定版になる前に変更される可能性があります。
 
-You can use the `signal` function to hold some state in your Angular code. Sometimes, this state depends on some _other_ state. For example, imagine a component that lets the user select a shipping method for an order:
+`signal`関数は、Angularコードで状態を保持するために使用できます。この状態は、他の状態に依存することがあります。たとえば、ユーザーが注文の配送方法を選択できるコンポーネントを考えてみましょう。
 
 ```typescript
 @Component({/* ... */})
 export class ShippingMethodPicker {
   shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
 
-  // Select the first shipping option by default.
+  // デフォルトで最初の配送オプションを選択します。
   selectedOption = signal(this.shippingOptions()[0]);
 
   changeShipping(newOptionIndex: number) {
     this.selectedOption.set(this.shippingOptions()[newOptionIndex]);
   }
 }
-``` 
+```
 
-In this example, the `selectedOption` defaults to the first option, but changes if the user selects another option. But `shippingOptions` is a signal— its value may change! If `shippingOptions` changes, `selectedOption` may contain a value that is no longer a valid option.
+この例では、`selectedOption`は最初のオプションにデフォルト設定されますが、ユーザーが別のオプションを選択すると変更されます。しかし、`shippingOptions`はシグナルであり、その値は変更される可能性があります！`shippingOptions`が変更されると、`selectedOption`はもはや有効なオプションではない値を含む可能性があります。
 
-**The `linkedSignal` function lets you create a signal to hold some state that is intrinsically _linked_ to some other state.** Revisiting the example above, `linkedSignal` can replace `signal`:
+**`linkedSignal`関数は、本質的に他の状態に_リンク_された状態を保持するシグナルを作成できます。**上記の例を再考すると、`linkedSignal`は`signal`を置き換えることができます。
 
 ```typescript
 @Component({/* ... */})
 export class ShippingMethodPicker {
   shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
 
-  // Initialize selectedOption to the first shipping option.
+  // selectedOptionを最初の配送オプションに初期化します。
   selectedOption = linkedSignal(() => this.shippingOptions()[0]);
 
   changeShipping(index: number) {
@@ -36,9 +36,9 @@ export class ShippingMethodPicker {
 }
 ```
 
-`linkedSignal` works similarly to `signal` with one key difference— instead of passing a default value, you pass a _computation function_, just like `computed`. When the value of the computation changes, the value of the `linkedSignal` changes to the computation result. This helps ensure that the `linkedSignal` always has a valid value.
+`linkedSignal`は`signal`と同様に動作しますが、重要な違いが1つあります。デフォルト値を渡す代わりに、`computed`のように*算出関数*を渡します。算出値が変更されると、`linkedSignal`の値は計算結果に変更されます。これは、`linkedSignal`が常に有効な値を持つようにするのに役立ちます。
 
-The following example shows how the value of a `linkedSignal` can change based on its linked state:
+次の例は、`linkedSignal`の値がリンクされた状態に基づいてどのように変化するかを示しています。
 
 ```typescript
 const shippingOptions = signal(['Ground', 'Air', 'Sea']);
@@ -52,23 +52,23 @@ shippingOptions.set(['Email', 'Will Call', 'Postal service']);
 console.log(selectedOption()); // 'Email'
 ```
 
-## Accounting for previous state
+## 以前の状態を考慮する
 
-In some cases, the computation for a `linkedSignal` needs to account for the previous value of the `linkedSignal`.
+場合によっては、`linkedSignal`の計算で`linkedSignal`の以前の値を考慮する必要があります。
 
-In the example above, `selectedOption` always updates back to the first option when `shippingOptions` changes. You may, however, want to preserve the user's selection if their selected option is still somewhere in the list. To accomplish this, you can create a `linkedSignal` with a separate _source_ and _computation_:
+上記の例では、`shippingOptions`が変更されると、`selectedOption`は常に最初のオプションに戻って更新されます。ただし、選択したオプションがリスト内にまだ存在する場合は、ユーザーの選択を維持したい場合があります。これを実現するには、別々の*ソース*と*算出*を使用して`linkedSignal`を作成できます。
 
 ```typescript
 @Component({/* ... */})
 export class ShippingMethodPicker {
   shippingOptions: Signal<ShippingMethod[]> = getShippingOptions();
 
   selectedOption = linkedSignal({
-    // `selectedOption` is set to the `computation` result whenever this `source` changes.
+    // この`source`が変更されるたびに、`selectedOption`は`computation`の結果に設定されます。
     source: shippingOptions,
     computation: (newOptions, previous) => {
-      // If the newOptions contain the previously selected option, preserve that selection.
-      // Otherwise, default to the first option.
+      // newOptionsに以前選択したオプションが含まれている場合、その選択を保持します。
+      // そうでない場合は、最初のオプションをデフォルトとします。
       return newOptions.find(opt => opt.id === previous?.value) ?? newOptions[0];
     } 
   });
@@ -79,31 +79,31 @@ export class ShippingMethodPicker {
 }
 ```
 
-When you create a `linkedSignal`, you can pass an object with separate `source` and `computation` properties instead of providing just a computation.
+`linkedSignal`を作成する際には、算出だけを提供する代わりに、個別の`source`プロパティと`computation`プロパティを持つオブジェクトを渡すことができます。
 
-The `source` can be any signal, such as a `computed` or component `input`. When the value of `source` changes, `linkedSignal` updates its value to the result of the provided `computation`.
+`source`は、`computed`やコンポーネントの`input`などの任意のシグナルにできます。`source`の値が変更されると、`linkedSignal`は提供された`computation`の結果にその値を更新します。
 
-The `computation` is a function that receives the new value of `source` and a `previous` object. The `previous` object has two properties— `previous.source` is the previous value of `source`, and `previous.value` is the previous result of the `computation`. You can use these previous values to decide the new result of the computation.
+`computation`は、`source`の新しい値と`previous`オブジェクトを受け取る関数です。`previous`オブジェクトには、`previous.source`（`source`の以前の値）、`previous.value`（`computation`の以前の結果）の2つのプロパティがあります。これらの以前の値を使用して、計算の新しい結果を決定できます。
 
-## Custom equality comparison
+## カスタムの等価比較
 
-`linkedSignal` updates to the result of the computation every time its linked state changes. By default, Angular uses referential equality to determine if the linked state has changed. You can alternatively provide a custom equality function.
+`linkedSignal`は、リンクされた状態が変更されるたびに算出の結果に更新されます。デフォルトでは、Angularは参照の等価性を使用して、リンクされた状態が変更されたかどうかを判断します。代わりに、カスタムの等価関数の指定ができます。
 
 ```typescript
 const activeUser = signal({id: 123, name: 'Morgan'});
 const email = linkedSignal(() => `${activeUser().name}@example.com`, {
-  // Consider the user as the same if it's the same `id`.
+  // `id`が同じであれば、ユーザーは同じとみなします。
   equal: (a, b) => a.id === b.id,
 });
 
-// Or, if separating `source` and `computation`
+// または、`source`と`computation`を分離する場合
 const alternateEmail = linkedSignal({
   source: activeUser,
   computation: user => `${user.name}@example.com`,
   equal: (a, b) => a.id === b.id,
 });
 
-// This update to `activeUser` does not cause `email` or `alternateEmail`
-// to update because the `id` is the same.
+// `activeUser`へのこの更新は、`id`が同じであるため、
+// `email`または`alternateEmail`を更新しません。
 activeUser.set({id: 123, name: 'Morgan', isAdmin: false});
 ```